Add isFunction and isNullable builtins

src/builtins.ts

@@ -76,6 +76,8 @@ export namespace BuiltinSymbols {
   export const isReference = "~lib/builtins/isReference";
   export const isString = "~lib/builtins/isString";
   export const isArray = "~lib/builtins/isArray";
+  export const isFunction = "~lib/builtins/isFunction";
+  export const isNullable = "~lib/builtins/isNullable";
   export const isDefined = "~lib/builtins/isDefined";
   export const isConstant = "~lib/builtins/isConstant";
   export const isManaged = "~lib/builtins/isManaged";
@@ -348,6 +350,18 @@ export function compileCall(
           : 0
       );
     }
+    case BuiltinSymbols.isFunction: { // isFunction<T!> / isFunction<T?>(value: T) -> bool
+      let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);
+      compiler.currentType = Type.bool;
+      if (!type) return module.createUnreachable();
+      return module.createI32(type.signatureReference ? 1 : 0);
+    }
+    case BuiltinSymbols.isNullable: { // isNullable<T!> / isNullable<T?>(value: T) -> bool
+      let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);
+      compiler.currentType = Type.bool;
+      if (!type) return module.createUnreachable();
+      return module.createI32(type.is(TypeFlags.NULLABLE) ? 1 : 0);
+    }
     case BuiltinSymbols.isDefined: { // isDefined(expression) -> bool
       compiler.currentType = Type.bool;
       if (typeArguments) {

std/assembly/builtins.ts

@@ -9,6 +9,8 @@
 @builtin export declare function isReference<T>(value?: T): bool;
 @builtin export declare function isString<T>(value?: T): bool;
 @builtin export declare function isArray<T>(value?: T): bool;
+@builtin export declare function isFunction<T>(value?: T): bool;
+@builtin export declare function isNullable<T>(value?: T): bool;
 @builtin export declare function isDefined(expression: void): bool;
 @builtin export declare function isConstant(expression: void): bool;
 @builtin export declare function isManaged<T>(value?: T): bool;

std/assembly/index.d.ts

@@ -128,6 +128,10 @@ declare function isReference<T>(value?: any): value is object | string;
 declare function isString<T>(value?: any): value is string | String;
 /** Tests if the specified type *or* expression can be used as an array. Compiles to a constant. */
 declare function isArray<T>(value?: any): value is Array<any>;
+/** Tests if the specified type *or* expression is of a function type. Compiles to a constant. */
+declare function isFunction<T>(value?: any): value is Array<any>;
+/** Tests if the specified type *or* expression is of a nullable reference type. Compiles to a constant. */
+declare function isNullable<T>(value?: any): value is Array<any>;
 /** Tests if the specified expression resolves to a defined element. Compiles to a constant. */
 declare function isDefined(expression: any): bool;
 /** Tests if the specified expression evaluates to a constant value. Compiles to a constant. */

tests/compiler/builtins.optimized.wat

@@ -43,7 +43,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 50
+   i32.const 59
    i32.const 19
    call $~lib/env/abort
    unreachable
@@ -56,7 +56,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 51
+   i32.const 60
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -69,7 +69,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 52
+   i32.const 61
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -92,7 +92,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 68
+   i32.const 77
    i32.const 19
    call $~lib/env/abort
    unreachable
@@ -105,7 +105,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 69
+   i32.const 78
    i32.const 20
    call $~lib/env/abort
    unreachable
@@ -118,7 +118,7 @@
   if
    i32.const 0
    i32.const 8
-   i32.const 70
+   i32.const 79
    i32.const 20
    call $~lib/env/abort
    unreachable

tests/compiler/builtins.ts

@@ -1,4 +1,5 @@
 var b: bool;
+class C {}
 
 // type checks
 
@@ -10,6 +11,10 @@ assert(isReference<string>());
 assert(!isReference<usize>());
 assert(isArray<i32[]>());
 assert(!isArray<usize>());
+assert(isFunction<() => void>());
+assert(!isFunction<u32>());
+assert(isNullable<C | null>());
+assert(!isNullable<C>());
 
 assert(isInteger(<i32>1));
 assert(!isInteger(<f32>1));
@@ -21,6 +26,10 @@ assert(isString("1"));
 assert(!isString(1));
 assert(isArray(changetype<i32[]>(null)));
 assert(!isArray(changetype<usize>(null)));
+assert(isFunction(changetype<() => void>(null)));
+assert(!isFunction(changetype<u32>(null)));
+assert(isNullable(changetype<C | null>(null)));
+assert(!isNullable(changetype<C>(null)));
 
 // evaluation