Implement isDefined and isConstant builtins

Author: dcodeIO

dist/asc.js

@@ -51,6 +51,11 @@ import {
   FlowFlags
 } from "./program";
 
+import {
+  ReportMode
+} from "./resolver";
+import { CommonFlags } from "./common";
+
 /** Compiles a call to a built-in function. */
 export function compileCall(
   compiler: Compiler,
@@ -128,6 +133,57 @@ export function compileCall(
         ? module.createI32(1)
         : module.createI32(0);
     }
+    case "isDefined": { // isDefined(expression) -> bool
+      compiler.currentType = Type.bool;
+      if (operands.length != 1) {
+        if (typeArguments) {
+          compiler.error(
+            DiagnosticCode.Type_0_is_not_generic,
+            reportNode.range, prototype.internalName
+          );
+        }
+        compiler.error(
+          DiagnosticCode.Expected_0_arguments_but_got_1,
+          reportNode.range, "1", operands.length.toString(10)
+        );
+        return module.createUnreachable();
+      }
+      if (typeArguments) {
+        compiler.error(
+          DiagnosticCode.Type_0_is_not_generic,
+          reportNode.range, prototype.internalName
+        );
+        return module.createUnreachable();
+      }
+      let element = compiler.resolver.resolveExpression(operands[0], compiler.currentFunction, ReportMode.SWALLOW);
+      return module.createI32(element ? 1 : 0);
+    }
+    case "isConstant": { // isConstant(expression) -> bool
+      compiler.currentType = Type.bool;
+      if (operands.length != 1) {
+        if (typeArguments) {
+          compiler.error(
+            DiagnosticCode.Type_0_is_not_generic,
+            reportNode.range, prototype.internalName
+          );
+        }
+        compiler.error(
+          DiagnosticCode.Expected_0_arguments_but_got_1,
+          reportNode.range, "1", operands.length.toString(10)
+        );
+        return module.createUnreachable();
+      }
+      if (typeArguments) {
+        compiler.error(
+          DiagnosticCode.Type_0_is_not_generic,
+          reportNode.range, prototype.internalName
+        );
+        return module.createUnreachable();
+      }
+      let expr = compiler.compileExpressionRetainType(operands[0], Type.i32, WrapMode.NONE);
+      compiler.currentType = Type.bool;
+      return module.createI32(getExpressionId(expr) == ExpressionId.Const ? 1 : 0);
+    }
 
     // math
 

dist/asc.js.map

@@ -4623,7 +4623,7 @@ export class Compiler extends DiagnosticEmitter {
         return this.module.createUnreachable();
       }
       case ElementKind.CLASS: {
-        if (resolver.resolvedElementExpression) { // indexed access
+        if (resolver.currentElementExpression) { // indexed access
           let isUnchecked = currentFunction.flow.is(FlowFlags.UNCHECKED_CONTEXT);
           let indexedSet = (<Class>target).lookupOverload(OperatorKind.INDEXED_SET, isUnchecked);
           if (!indexedSet) {
@@ -4736,7 +4736,7 @@ export class Compiler extends DiagnosticEmitter {
           );
           return module.createUnreachable();
         }
-        let thisExpression = assert(this.resolver.resolvedThisExpression);
+        let thisExpression = assert(this.resolver.currentThisExpression);
         let thisExpr = this.compileExpressionRetainType(
           thisExpression,
           this.options.usizeType,
@@ -4788,7 +4788,7 @@ export class Compiler extends DiagnosticEmitter {
           // call just the setter if the return value isn't of interest
           if (!tee) {
             if (setterInstance.is(CommonFlags.INSTANCE)) {
-              let thisExpression = assert(this.resolver.resolvedThisExpression);
+              let thisExpression = assert(this.resolver.currentThisExpression);
               let thisExpr = this.compileExpressionRetainType(
                 thisExpression,
                 this.options.usizeType,
@@ -4808,7 +4808,7 @@ export class Compiler extends DiagnosticEmitter {
           let returnType = getterInstance.signature.returnType;
           let nativeReturnType = returnType.toNativeType();
           if (setterInstance.is(CommonFlags.INSTANCE)) {
-            let thisExpression = assert(this.resolver.resolvedThisExpression);
+            let thisExpression = assert(this.resolver.currentThisExpression);
             let thisExpr = this.compileExpressionRetainType(
               thisExpression,
               this.options.usizeType,
@@ -4841,7 +4841,7 @@ export class Compiler extends DiagnosticEmitter {
         return module.createUnreachable();
       }
       case ElementKind.CLASS: {
-        let elementExpression = this.resolver.resolvedElementExpression;
+        let elementExpression = this.resolver.currentElementExpression;
         if (elementExpression) {
           let isUnchecked = this.currentFunction.flow.is(FlowFlags.UNCHECKED_CONTEXT);
           let indexedGet = (<Class>target).lookupOverload(OperatorKind.INDEXED_GET, isUnchecked);
@@ -4862,7 +4862,7 @@ export class Compiler extends DiagnosticEmitter {
             return module.createUnreachable();
           }
           let targetType = (<Class>target).type;
-          let thisExpression = assert(this.resolver.resolvedThisExpression);
+          let thisExpression = assert(this.resolver.currentThisExpression);
           let thisExpr = this.compileExpressionRetainType(
             thisExpression,
             this.options.usizeType,
@@ -5039,7 +5039,7 @@ export class Compiler extends DiagnosticEmitter {
         let thisExpr: ExpressionRef = 0;
         if (instance.is(CommonFlags.INSTANCE)) {
           thisExpr = this.compileExpressionRetainType(
-            assert(this.resolver.resolvedThisExpression),
+            assert(this.resolver.currentThisExpression),
             this.options.usizeType,
             WrapMode.NONE
           );
@@ -5082,7 +5082,7 @@ export class Compiler extends DiagnosticEmitter {
       case ElementKind.FIELD: {
         let type = (<Field>target).type;
         if (signature = type.signatureReference) {
-          let thisExpression = assert(this.resolver.resolvedThisExpression);
+          let thisExpression = assert(this.resolver.currentThisExpression);
           let thisExpr = this.compileExpressionRetainType(
             thisExpression,
             this.options.usizeType,
@@ -6598,7 +6598,7 @@ export class Compiler extends DiagnosticEmitter {
         return module.createGetGlobal((<EnumValue>target).internalName, NativeType.I32);
       }
       case ElementKind.FIELD: { // instance field
-        let thisExpression = assert(this.resolver.resolvedThisExpression);
+        let thisExpression = assert(this.resolver.currentThisExpression);
         assert((<Field>target).memoryOffset >= 0);
         let thisExpr = this.compileExpressionRetainType(
           thisExpression,
@@ -6632,7 +6632,7 @@ export class Compiler extends DiagnosticEmitter {
           if (instance.is(CommonFlags.INSTANCE)) {
             let parent = assert(instance.parent);
             assert(parent.kind == ElementKind.CLASS);
-            let thisExpression = assert(this.resolver.resolvedThisExpression);
+            let thisExpression = assert(this.resolver.currentThisExpression);
             let thisExpr = this.compileExpressionRetainType(
               thisExpression,
               this.options.usizeType,

dist/assemblyscript.js

@@ -60,7 +60,7 @@ import {
 } from "./common";
 
 /** Indicates whether errors are reported or not. */
-enum ReportMode {
+export enum ReportMode {
   /** Report errors. */
   REPORT,
   /** Swallow errors. */
@@ -72,10 +72,11 @@ export class Resolver extends DiagnosticEmitter {
 
   /** The program this resolver belongs to. */
   program: Program;
+
   /** Target expression of the previously resolved property or element access. */
-  resolvedThisExpression: Expression | null = null;
+  currentThisExpression: Expression | null = null;
   /** Element expression of the previously resolved element access. */
-  resolvedElementExpression : Expression | null = null;
+  currentElementExpression : Expression | null = null;
 
   /** Constructs the resolver for the specified program. */
   constructor(program: Program) {
@@ -306,8 +307,8 @@ export class Resolver extends DiagnosticEmitter {
         case ElementKind.FUNCTION: { // search locals, use prototype
           element = (<Function>context).flow.getScopedLocal(name);
           if (element) {
-            this.resolvedThisExpression = null;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = null;
+            this.currentElementExpression = null;
             return element;
           }
           context = (<Function>context).prototype.parent;
@@ -324,8 +325,8 @@ export class Resolver extends DiagnosticEmitter {
         let members = context.members;
         if (members) {
           if (element = members.get(name)) {
-            this.resolvedThisExpression = null;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = null;
+            this.currentElementExpression = null;
             return element;
           }
         }
@@ -336,15 +337,15 @@ export class Resolver extends DiagnosticEmitter {
     // search current file
     var elementsLookup = this.program.elementsLookup;
     if (element = elementsLookup.get(identifier.range.source.internalPath + PATH_DELIMITER + name)) {
-      this.resolvedThisExpression = null;
-      this.resolvedElementExpression = null;
+      this.currentThisExpression = null;
+      this.currentElementExpression = null;
       return element; // GLOBAL, FUNCTION_PROTOTYPE, CLASS_PROTOTYPE
     }
 
     // search global scope
     if (element = elementsLookup.get(name)) {
-      this.resolvedThisExpression = null;
-      this.resolvedElementExpression = null;
+      this.currentThisExpression = null;
+      this.currentElementExpression = null;
       return element; // GLOBAL, FUNCTION_PROTOTYPE, CLASS_PROTOTYPE
     }
 
@@ -407,7 +408,7 @@ export class Resolver extends DiagnosticEmitter {
         break;
       }
       case ElementKind.CLASS: {
-        let elementExpression = this.resolvedElementExpression;
+        let elementExpression = this.currentElementExpression;
         if (elementExpression) {
           let indexedGet = (<Class>target).lookupOverload(OperatorKind.INDEXED_GET);
           if (!indexedGet) {
@@ -438,8 +439,8 @@ export class Resolver extends DiagnosticEmitter {
           let members = target.members;
           let member: Element | null;
           if (members && (member = members.get(propertyName))) {
-            this.resolvedThisExpression = targetExpression;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = targetExpression;
+            this.currentElementExpression = null;
             return member; // instance FIELD, static GLOBAL, FUNCTION_PROTOTYPE...
           }
           // traverse inherited static members on the base prototype if target is a class prototype
@@ -467,8 +468,8 @@ export class Resolver extends DiagnosticEmitter {
         if (members) {
           let member = members.get(propertyName);
           if (member) {
-            this.resolvedThisExpression = targetExpression;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = targetExpression;
+            this.currentElementExpression = null;
             return member; // static ENUMVALUE, static GLOBAL, static FUNCTION_PROTOTYPE...
           }
         }
@@ -496,8 +497,8 @@ export class Resolver extends DiagnosticEmitter {
       case ElementKind.FIELD: {
         let type = (<VariableLikeElement>target).type;
         if (target = type.classReference) {
-          this.resolvedThisExpression = targetExpression;
-          this.resolvedElementExpression = elementAccess.elementExpression;
+          this.currentThisExpression = targetExpression;
+          this.currentElementExpression = elementAccess.elementExpression;
           return target;
         }
         break;
@@ -515,8 +516,8 @@ export class Resolver extends DiagnosticEmitter {
         }
         let returnType = indexedGet.signature.returnType;
         if (target = returnType.classReference) {
-          this.resolvedThisExpression = targetExpression;
-          this.resolvedElementExpression = elementAccess.elementExpression;
+          this.currentThisExpression = targetExpression;
+          this.currentElementExpression = elementAccess.elementExpression;
           return target;
         }
         break;
@@ -549,8 +550,8 @@ export class Resolver extends DiagnosticEmitter {
         if (type) {
           let classType = type.classReference;
           if (classType) {
-            this.resolvedThisExpression = null;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = null;
+            this.currentElementExpression = null;
             return classType;
           }
         }
@@ -563,15 +564,15 @@ export class Resolver extends DiagnosticEmitter {
         if (contextualFunction.flow.is(FlowFlags.INLINE_CONTEXT)) {
           let explicitLocal = contextualFunction.flow.getScopedLocal("this");
           if (explicitLocal) {
-            this.resolvedThisExpression = null;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = null;
+            this.currentElementExpression = null;
             return explicitLocal;
           }
         }
         let parent = contextualFunction.parent;
         if (parent) {
-          this.resolvedThisExpression = null;
-          this.resolvedElementExpression = null;
+          this.currentThisExpression = null;
+          this.currentElementExpression = null;
           return parent;
         }
         if (reportMode == ReportMode.REPORT) {
@@ -586,15 +587,15 @@ export class Resolver extends DiagnosticEmitter {
         if (contextualFunction.flow.is(FlowFlags.INLINE_CONTEXT)) {
           let explicitLocal = contextualFunction.flow.getScopedLocal("super");
           if (explicitLocal) {
-            this.resolvedThisExpression = null;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = null;
+            this.currentElementExpression = null;
             return explicitLocal;
           }
         }
         let parent = contextualFunction.parent;
         if (parent && parent.kind == ElementKind.CLASS && (parent = (<Class>parent).base)) {
-          this.resolvedThisExpression = null;
-          this.resolvedElementExpression = null;
+          this.currentThisExpression = null;
+          this.currentElementExpression = null;
           return parent;
         }
         if (reportMode == ReportMode.REPORT) {
@@ -611,8 +612,8 @@ export class Resolver extends DiagnosticEmitter {
       case NodeKind.LITERAL: {
         switch ((<LiteralExpression>expression).literalKind) {
           case LiteralKind.STRING: {
-            this.resolvedThisExpression = expression;
-            this.resolvedElementExpression = null;
+            this.currentThisExpression = expression;
+            this.currentElementExpression = null;
             return this.program.stringInstance;
           }
           // case LiteralKind.ARRAY: // TODO

dist/assemblyscript.js.map

@@ -10,6 +10,10 @@ export declare function isString<T>(value?: T): bool;
 
 export declare function isArray<T>(value?: T): bool;
 
+export declare function isDefined(expression: void): bool;
+
+export declare function isConstant(expression: void): bool;
+
 export const NaN: f64 = 0 / 0;
 
 export const Infinity: f64 = 1 / 0;

src/builtins.ts

@@ -304,6 +304,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 expression resolves to a defined element. */
+declare function isDefined(expression: any): bool;
+/** Tests if the specified expression evaluates to a constant value. */
+declare function isConstant(expression: any): bool;
 /** Traps if the specified value is not true-ish, otherwise returns the (non-nullable) value. */
 declare function assert<T>(isTrueish: T, message?: string): T & object; // any better way to model `: T != null`?
 /** Parses an integer string to a 64-bit float. */