[Implement] idof function references

Author: jtenner

src/builtins.ts

@@ -3592,7 +3592,12 @@ export function compileCall(
     case BuiltinSymbols.idof: {
       let type = evaluateConstantType(compiler, typeArguments, operands, reportNode);
       compiler.currentType = Type.u32;
-      if (!type) return module.unreachable();
+      if (!type || checkArgsOptional(operands, 0, 0, reportNode, compiler)) return module.unreachable();
+
+      if (type.is(TypeFlags.REFERENCE) && type.signatureReference !== null) {
+        return module.i32(type.signatureReference.id);
+      }
+
       let classReference = type.classReference;
       if (!classReference || classReference.hasDecorator(DecoratorFlags.UNMANAGED)) {
         compiler.error(

src/compiler.ts

@@ -305,6 +305,8 @@ export class Compiler extends DiagnosticEmitter {
   runtimeFeatures: RuntimeFeatures = RuntimeFeatures.NONE;
   /** Expressions known to have skipped an autorelease. Usually function returns. */
   skippedAutoreleases: Set<ExpressionRef> = new Set();
+  /** A table of signatures. */
+  signatures: Signature[] = new Array<Signature>(0);
 
   /** Compiles a {@link Program} to a {@link Module} using the specified options. */
   static compile(program: Program, options: Options | null = null): Module {
@@ -344,7 +346,7 @@ export class Compiler extends DiagnosticEmitter {
     program.initialize(options);
 
     // set up the main start function
-    var startFunctionInstance = program.makeNativeFunction("start", new Signature([], Type.void));
+    var startFunctionInstance = program.makeNativeFunction("start", new Signature(program, [], Type.void, null));
     startFunctionInstance.internalName = "start";
     var startFunctionBody = new Array<ExpressionRef>();
     this.currentFlow = startFunctionInstance.flow;
@@ -6367,7 +6369,7 @@ export class Compiler extends DiagnosticEmitter {
     assert(operandIndex == minOperands);
 
     // create the trampoline element
-    var trampolineSignature = new Signature(originalParameterTypes, returnType, thisType);
+    var trampolineSignature = new Signature(this.program, originalParameterTypes, returnType, thisType);
     trampolineSignature.requiredParameters = maxArguments;
     trampolineSignature.parameterNames = originalSignature.parameterNames;
     trampoline = new Function(
@@ -7082,7 +7084,7 @@ export class Compiler extends DiagnosticEmitter {
         }
       }
 
-      let signature = new Signature(parameterTypes, returnType, thisType);
+      let signature = new Signature(this.program, parameterTypes, returnType, thisType);
       signature.requiredParameters = numParameters; // !
       signature.parameterNames = parameterNames;
       instance = new Function(
@@ -7845,7 +7847,7 @@ export class Compiler extends DiagnosticEmitter {
             CommonFlags.INSTANCE | CommonFlags.CONSTRUCTOR
           )
         ),
-        new Signature(null, classInstance.type, classInstance.type),
+        new Signature(this.program, null, classInstance.type, classInstance.type),
         null
       );
     }
@@ -9009,6 +9011,7 @@ export class Compiler extends DiagnosticEmitter {
     flow.popBreakLabel();
     return module.block(label, conditions, NativeType.I32);
   }
+
 }
 
 // helpers

src/program.ts

@@ -336,6 +336,8 @@ export class Program extends DiagnosticEmitter {
   typeClasses: Map<TypeKind,Class> = new Map();
   /** Managed classes contained in the program, by id. */
   managedClasses: Map<i32,Class> = new Map();
+  signatureTypes: Signature[] = new Array<Signature>(0);
+  signatureID: i32 = 0;
 
   // standard references
 
@@ -2141,7 +2143,7 @@ export class File extends Element {
     program.filesByName.set(this.internalName, this);
     var startFunction = this.program.makeNativeFunction(
       "start:" + this.internalName,
-      new Signature(null, Type.void),
+      new Signature(program, null, Type.void),
       this
     );
     startFunction.internalName = startFunction.name;

src/resolver.ts

@@ -405,7 +405,7 @@ export class Resolver extends DiagnosticEmitter {
       );
       if (!returnType) return null;
     }
-    var signature = new Signature(parameterTypes, returnType, thisType);
+    var signature = new Signature(this.program, parameterTypes, returnType, thisType);
     signature.parameterNames = parameterNames;
     signature.requiredParameters = requiredParameters;
     signature.hasRest = hasRest;
@@ -1551,7 +1551,7 @@ export class Resolver extends DiagnosticEmitter {
       returnType = type;
     }
 
-    var signature = new Signature(parameterTypes, returnType, thisType);
+    var signature = new Signature(this.program, parameterTypes, returnType, thisType);
     signature.parameterNames = parameterNames;
     signature.requiredParameters = requiredParameters;
 

src/types.ts

@@ -556,7 +556,8 @@ export function typesToString(types: Type[]): string {
 
 /** Represents a fully resolved function signature. */
 export class Signature {
-
+  /** The unique program id that represents this signature. */
+  id: i32 = -1;
   /** Parameter types, if any, excluding `this`. */
   parameterTypes: Type[];
   /** Parameter names, if known, excluding `this`. */
@@ -573,20 +574,38 @@ export class Signature {
   cachedFunctionTarget: FunctionTarget | null = null;
   /** Respective function type. */
   type: Type;
+  /** The program that created this signature. */
+  program: Program;
 
   /** Constructs a new signature. */
   constructor(
+    program: Program,
     parameterTypes: Type[] | null = null,
     returnType: Type | null = null,
-    thisType: Type | null = null
+    thisType: Type | null = null,
   ) {
     this.parameterTypes = parameterTypes ? parameterTypes : [];
     this.parameterNames = null;
     this.requiredParameters = 0;
     this.returnType = returnType ? returnType : Type.void;
     this.thisType = thisType;
+    this.program = program;
     this.hasRest = false;
     this.type = Type.u32.asFunction(this);
+
+    let compare: Signature;
+    let signatureTypes = program.signatureTypes;
+    let length = signatureTypes.length;
+    for (let i = 0; i < length; i++) {
+      compare = signatureTypes[i];
+      if (this.isAssignableTo(compare)) {
+        this.id = compare.id;
+      }
+    }
+    if (this.id === -1) {
+      program.signatureTypes.push(this);
+      this.id = program.signatureID++;
+    }
   }
 
   asFunctionTarget(program: Program): FunctionTarget {

std/assembly/builtins.ts

@@ -1,3 +1,5 @@
+import { I32 } from "number";
+
 // @ts-ignore: decorator
 @builtin
 export declare function isInteger<T>(value?: T): bool;
@@ -130,6 +132,10 @@ export declare function alignof<T>(): usize; // | u32 / u64
 @builtin
 export declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64
 
+// @ts-ignore: decorator
+@builtin
+export declare function signatureof<T>(): i32;
+
 // @ts-ignore: decorator
 @builtin
 export declare function idof<T>(): u32;

std/assembly/index.d.ts

@@ -112,6 +112,8 @@ declare function sizeof<T>(): usize;
 declare function alignof<T>(): usize;
 /** Determines the end offset of the given class type. Compiles to a constant. */
 declare function offsetof<T>(): usize;
+/** Determines the unique signature id of a given function. */
+declare function signatureof<T extends (...params: any[]) => any>(): i32;
 /** Determines the offset of the specified field within the given class type. Compiles to a constant. */
 declare function offsetof<T>(fieldName: keyof T | string): usize;
 /** Determines the offset of the specified field within the given class type. Returns the class type's end offset if field name has been omitted. Compiles to a constant. */

tests/compiler/binary.optimized.wat

@@ -29,8 +29,6 @@
   local.get $2
   i32.wrap_i64
   i32.const 0
-  i32.ne
-  i32.const 0
   local.get $1
   i32.const 2147483647
   i32.and

tests/compiler/builtins.optimized.wat

@@ -3,12 +3,15 @@
  (type $FUNCSIG$if (func (param f32) (result i32)))
  (type $FUNCSIG$id (func (param f64) (result i32)))
  (type $FUNCSIG$vii (func (param i32 i32)))
+ (type $FUNCSIG$viiddddd (func (param i32 i32 f64 f64 f64 f64 f64)))
  (type $FUNCSIG$v (func))
  (import "env" "abort" (func $~lib/builtins/abort (param i32 i32 i32 i32)))
+ (import "env" "trace" (func $~lib/builtins/trace (param i32 i32 f64 f64 f64 f64 f64)))
  (memory $0 1)
  (data (i32.const 12) "\01\00\00\00\01")
  (data (i32.const 24) "\06\00\00\00\01\00\00\00\01\00\00\00\06\00\00\00a\00b\00c")
  (data (i32.const 48) "\16\00\00\00\01\00\00\00\01\00\00\00\16\00\00\00b\00u\00i\00l\00t\00i\00n\00s\00.\00t\00s")
+ (data (i32.const 88) "\14\00\00\00\01\00\00\00\01\00\00\00\14\00\00\00s\00i\00g\00n\00a\00t\00u\00r\00e\00s")
  (table $0 2 funcref)
  (elem (i32.const 0) $builtins/test $start:builtins~anonymous|0)
  (global $builtins/b (mut i32) (i32.const 0))
@@ -23,34 +26,34 @@
  (export "memory" (memory $0))
  (export "test" (func $builtins/test))
  (start $start)
- (func $~lib/number/isNaN<f32> (; 1 ;) (type $FUNCSIG$if) (param $0 f32) (result i32)
+ (func $~lib/number/isNaN<f32> (; 2 ;) (type $FUNCSIG$if) (param $0 f32) (result i32)
   local.get $0
   local.get $0
   f32.ne
  )
- (func $~lib/number/isFinite<f32> (; 2 ;) (type $FUNCSIG$if) (param $0 f32) (result i32)
+ (func $~lib/number/isFinite<f32> (; 3 ;) (type $FUNCSIG$if) (param $0 f32) (result i32)
   local.get $0
   local.get $0
   f32.sub
   f32.const 0
   f32.eq
  )
- (func $~lib/number/isNaN<f64> (; 3 ;) (type $FUNCSIG$id) (param $0 f64) (result i32)
+ (func $~lib/number/isNaN<f64> (; 4 ;) (type $FUNCSIG$id) (param $0 f64) (result i32)
   local.get $0
   local.get $0
   f64.ne
  )
- (func $~lib/number/isFinite<f64> (; 4 ;) (type $FUNCSIG$id) (param $0 f64) (result i32)
+ (func $~lib/number/isFinite<f64> (; 5 ;) (type $FUNCSIG$id) (param $0 f64) (result i32)
   local.get $0
   local.get $0
   f64.sub
   f64.const 0
   f64.eq
  )
- (func $start:builtins~anonymous|0 (; 5 ;) (type $FUNCSIG$vii) (param $0 i32) (param $1 i32)
+ (func $start:builtins~anonymous|0 (; 6 ;) (type $FUNCSIG$vii) (param $0 i32) (param $1 i32)
   nop
  )
- (func $start:builtins (; 6 ;) (type $FUNCSIG$v)
+ (func $start:builtins (; 7 ;) (type $FUNCSIG$v)
   i32.const 31
   global.set $builtins/i
   i32.const 0
@@ -685,11 +688,19 @@
   i32.const 8
   f64.const 1
   f64.store
+  i32.const 104
+  i32.const 5
+  f64.const 0
+  f64.const 0
+  f64.const 12
+  f64.const 27
+  f64.const 27
+  call $~lib/builtins/trace
  )
- (func $builtins/test (; 7 ;) (type $FUNCSIG$v)
+ (func $builtins/test (; 8 ;) (type $FUNCSIG$v)
   nop
  )
- (func $start (; 8 ;) (type $FUNCSIG$v)
+ (func $start (; 9 ;) (type $FUNCSIG$v)
   call $start:builtins
  )
 )

tests/compiler/builtins.ts

@@ -418,3 +418,18 @@ f64.store(8, 1.0);
 
 f32.trunc(1.0);
 f64.trunc(1.0);
+
+
+{
+  let a = idof<() => void>();
+  let b = idof<() => void>();
+  let c = idof<(a: u32) => void>();
+  assert(a == b);
+  assert(a != c);
+  assert(c == idof<(b: u32) => void>());
+
+  let d = idof<(val: C) => C>();
+  let e = idof<(val2: C) => C>();
+  assert(d == e);
+  trace("signatures", 5, a, b, c, d, e);
+}