[Implement] nameof builtin

Author: jtenner

src/builtins.ts

@@ -135,6 +135,7 @@ export namespace BuiltinSymbols {
   export const sizeof = "~lib/builtins/sizeof";
   export const alignof = "~lib/builtins/alignof";
   export const offsetof = "~lib/builtins/offsetof";
+  export const nameof = "~lib/builtins/nameof";
   export const select = "~lib/builtins/select";
   export const unreachable = "~lib/builtins/unreachable";
   export const changetype = "~lib/builtins/changetype";
@@ -771,6 +772,62 @@ export function compileCall(
         }
       }
     }
+    case BuiltinSymbols.nameof: {
+      compiler.currentType = compiler.program.stringInstance.type;
+
+      if (checkTypeOptional(typeArguments, reportNode, compiler)
+        | checkArgsOptional(operands, 0, 1, reportNode, compiler)) {
+        compiler.error(
+          DiagnosticCode.Operation_not_supported,
+          reportNode.typeArgumentsRange
+        );
+        return module.unreachable();
+      }
+
+      let expression = new StringLiteralExpression();
+      let resultType: Type | null = null;
+
+      if (typeArguments !== null && typeArguments.length > 0) {
+        resultType = typeArguments[0];
+      } else {
+        resultType = evaluateConstantType(compiler, typeArguments, operands, reportNode);
+      }
+
+      if (resultType === null) {
+        compiler.error(
+          DiagnosticCode.Operation_not_supported,
+          reportNode.typeArgumentsRange
+        );
+        return module.unreachable();
+      }
+
+      if (resultType.classReference !== null) {
+        expression.value = resultType.classReference.name;
+      } else if (resultType.signatureReference !== null) {
+        expression.value = "Function";
+      } else {
+        let kind = resultType.kind;
+        switch (kind) {
+          case TypeKind.BOOL: expression.value = "bool"; break;
+          case TypeKind.I8: expression.value = "i8"; break;
+          case TypeKind.U8: expression.value = "u8"; break;
+          case TypeKind.I16: expression.value = "i16"; break;
+          case TypeKind.U16: expression.value = "u16"; break;
+          case TypeKind.I32: expression.value = "i32"; break;
+          case TypeKind.U32: expression.value = "u32"; break;
+          case TypeKind.F32: expression.value = "f32"; break;
+          case TypeKind.I64: expression.value = "i64"; break;
+          case TypeKind.U64: expression.value = "u64"; break;
+          case TypeKind.F64: expression.value = "f64"; break;
+          case TypeKind.ISIZE: expression.value = "isize"; break;
+          case TypeKind.USIZE: expression.value = "usize"; break;
+          case TypeKind.VOID: expression.value = "void"; break;
+          default: expression.value = "unknown"; break;
+        }
+      }
+
+      return compiler.compileStringLiteral(expression);
+    }
 
     // === Math ===================================================================================
 

std/assembly/builtins.ts

@@ -134,6 +134,10 @@ export declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64
 @builtin
 export declare function idof<T>(): u32;
 
+// @ts-ignore
+@builtin
+export declare function nameof<T>(): string;
+
 // @ts-ignore: decorator
 @builtin
 export declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;

std/assembly/index.d.ts

@@ -116,6 +116,8 @@ declare function offsetof<T>(): usize;
 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. */
 declare function offsetof<T>(fieldName?: string): usize;
+/** Determine the name of a given class type instance. */
+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;
 /** 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.*/

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