familyof for unmanaged classes. suggestion AssemblyScript#2097 (comment)

Author: RehkitzDev

src/builtins.ts

@@ -188,6 +188,7 @@ export namespace BuiltinNames {
   export const unchecked = "~lib/builtins/unchecked";
   export const instantiate = "~lib/builtins/instantiate";
   export const idof = "~lib/builtins/idof";
+  export const familyof = "~lib/builtins/familyof";
 
   export const i8 = "~lib/builtins/i8";
   export const i16 = "~lib/builtins/i16";
@@ -1085,6 +1086,36 @@ function builtin_idof(ctx: BuiltinContext): ExpressionRef {
 }
 builtins.set(BuiltinNames.idof, builtin_idof);
 
+
+function builtin_familyof(ctx: BuiltinContext): ExpressionRef {
+    var compiler = ctx.compiler;
+    var module = compiler.module;
+    var program = compiler.program;
+    var type = evaluateConstantType(ctx);
+    compiler.currentType = Type.u32;
+    if (!type) return module.unreachable();
+    let signatureReference = type.getSignature();
+    if (signatureReference) {
+        return module.i32(signatureReference.id);
+    }
+    let classReference = type.getClassOrWrapper(compiler.program);
+    
+    if(classReference !== null){
+      return module.i32(program.unmanagedClassNames.get(classReference.internalName) as i32);
+    }
+
+    compiler.error(
+        DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,
+        ctx.reportNode.typeArgumentsRange,
+        "familyof",
+        type.toString()
+    );
+    return module.unreachable();
+}
+
+// in Transform
+builtins.set(BuiltinNames.familyof, builtin_familyof);
+
 // === Math ===================================================================================
 
 // clz<T?>(value: T) -> T

src/program.ts

@@ -455,6 +455,8 @@ export class Program extends DiagnosticEmitter {
   nativeFile!: File;
   /** Next class id. */
   nextClassId: u32 = 0;
+  /** Next family id. */
+  nextFamilyId: u32 = 0;
   /** Next signature id. */
   nextSignatureId: i32 = 0;
   /** An indicator if the program has been initialized. */
@@ -474,6 +476,8 @@ export class Program extends DiagnosticEmitter {
   wrapperClasses: Map<Type,Class> = new Map();
   /** Managed classes contained in the program, by id. */
   managedClasses: Map<i32,Class> = new Map();
+  /** unmanaged classes contained in the program, by id. */
+  unmanagedClassNames: Map<string,i32> = new Map();
   /** A set of unique function signatures contained in the program, by id. */
   uniqueSignatures: Signature[] = new Array<Signature>(0);
 
@@ -4211,6 +4215,10 @@ export class Class extends TypedElement {
       this._id = id;
       program.managedClasses.set(id, this);
     }
+    else{
+      let id = program.nextFamilyId++;
+      program.unmanagedClassNames.set(this.internalName, id);
+    }
 
     // apply pre-checked instance-specific contextual type arguments
     var typeParameters = prototype.typeParameterNodes;

std/assembly/builtins.ts

@@ -160,6 +160,10 @@ export declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64
 @builtin
 export declare function idof<T>(): u32;
 
+// @ts-ignore: decorator
+@builtin
+export declare function familyof<T>(): u32;
+
 // @ts-ignore
 @builtin
 export declare function nameof<T>(): string;

std/assembly/index.d.ts

@@ -172,6 +172,8 @@ declare function offsetof<T>(fieldName?: string): usize;
 declare function nameof<T>(value?: T): string;
 /** Determines the unique runtime id of a class type. Compiles to a constant. */
 declare function idof<T>(): u32;
+/** Determines the unique runtime id of a unmanaged class type. Compiles to a constant. */
+declare function familyof<T>(): u32;
 /** Changes the type of any value of `usize` kind to another one of `usize` kind. Useful for casting class instances to their pointer values and vice-versa. Beware that this is unsafe.*/
 declare function changetype<T>(value: any): T;
 /** Explicitly requests no bounds checks on the provided expression. Useful for array accesses. */