Implement typeof expressions (#849)

Author: dcodeIO

src/compiler.ts

@@ -8736,11 +8736,7 @@ export class Compiler extends DiagnosticEmitter {
         break;
       }
       case Token.TYPEOF: {
-        this.error(
-          DiagnosticCode.Operation_not_supported,
-          expression.range
-        );
-        return module.unreachable();
+        return this.compileTypeof(expression, contextualType, constraints);
       }
       default: {
         assert(false);
@@ -8761,6 +8757,88 @@ export class Compiler extends DiagnosticEmitter {
     );
   }
 
+  compileTypeof(
+    expression: UnaryPrefixExpression,
+    contextualType: Type,
+    constraints: Constraints
+  ): ExpressionRef {
+    var operand = expression.operand;
+    var expr: ExpressionRef = 0;
+    var stringInstance = this.program.stringInstance;
+    var typeString: string;
+    if (operand.kind == NodeKind.NULL) {
+      typeString = "object"; // special since `null` without type context is usize
+    } else {
+      let element = this.resolver.lookupExpression(operand, this.currentFlow, Type.auto, ReportMode.SWALLOW);
+      if (!element) {
+        switch (operand.kind) {
+          case NodeKind.PROPERTYACCESS:
+          case NodeKind.ELEMENTACCESS: {
+            operand = operand.kind == NodeKind.PROPERTYACCESS
+              ? (<PropertyAccessExpression>operand).expression
+              : (<ElementAccessExpression>operand).expression;
+            let targetType = this.resolver.resolveExpression(operand, this.currentFlow, Type.auto, ReportMode.REPORT);
+            if (!targetType) {
+              this.currentType = stringInstance.type;
+              return this.module.unreachable();
+            }
+            expr = this.compileExpression(operand, Type.auto); // might have side-effects
+            break;
+          }
+          case NodeKind.IDENTIFIER: break; // ignore error
+          default: expr = this.compileExpression(operand, Type.auto); // trigger error
+        }
+        typeString = "undefined";
+      } else {
+        switch (element.kind) {
+          case ElementKind.CLASS_PROTOTYPE:
+          case ElementKind.NAMESPACE:
+          case ElementKind.ENUM: {
+            typeString = "object";
+            break;
+          }
+          case ElementKind.FUNCTION_PROTOTYPE: {
+            typeString = "function";
+            break;
+          }
+          default: {
+            expr = this.compileExpression(operand, Type.auto);
+            let type = this.currentType;
+            expr = this.convertExpression(expr, type, Type.void, true, false, operand);
+            if (type.is(TypeFlags.REFERENCE)) {
+              let signatureReference = type.signatureReference;
+              if (signatureReference) {
+                typeString = "function";
+              } else {
+                let classReference = type.classReference;
+                if (classReference) {
+                  if (classReference.prototype === stringInstance.prototype) {
+                    typeString = "string";
+                  } else {
+                    typeString = "object";
+                  }
+                } else {
+                  typeString = "anyref"; // TODO?
+                }
+              }
+            } else if (type == Type.bool) {
+              typeString = "boolean";
+            } else if (type.isAny(TypeFlags.FLOAT | TypeFlags.INTEGER)) {
+              typeString = "number";
+            } else {
+              typeString = "undefined"; // failed to compile?
+            }
+            break;
+          }
+        }
+      }
+    }
+    this.currentType = stringInstance.type;
+    return expr
+      ? this.module.block(null, [ expr, this.ensureStaticString(typeString) ], this.options.nativeSizeType)
+      : this.ensureStaticString(typeString);
+  }
+
   /** Makes sure that a 32-bit integer value is wrapped to a valid value of the specified type. */
   ensureSmallIntegerWrap(expr: ExpressionRef, type: Type): ExpressionRef {
     var module = this.module;

src/resolver.ts

@@ -1063,6 +1063,14 @@ export class Resolver extends DiagnosticEmitter {
     /** How to proceed with eventual diagnostics. */
     reportMode: ReportMode = ReportMode.REPORT
   ): Element | null {
+    switch (node.kind) {
+      case NodeKind.TRUE:
+      case NodeKind.FALSE:
+      case NodeKind.NULL: {
+        let type = this.resolveIdentifierExpression(node, ctxFlow, Type.auto, ctxElement, reportMode);
+        return type ? this.getElementOfType(type) : null;
+      }
+    }
     var name = node.text;
     var element: Element | null;
     if (element = ctxFlow.lookup(name)) {

tests/compiler/typeof.json

@@ -0,0 +1,6 @@
+{
+  "asc_flags": [
+    "--runtime none",
+    "--explicitStart"
+  ]
+}