AssemblyScript · dcodeIO · Oct 3, 2019
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -27,7 +27,7 @@
     "ts-node": "^6.2.0",
     "tslint": "^5.20.0",
     "typedoc-plugin-external-module-name": "^2.1.0",
-    "typescript": "^3.6.3",
+    "typescript": "^3.7.0-beta",
     "webpack": "^4.40.2",
     "webpack-cli": "^3.3.9"
   },

diff --git a/src/ast.ts b/src/ast.ts
@@ -53,6 +53,7 @@ export enum NodeKind {
   PARENTHESIZED,
   PROPERTYACCESS,
   TERNARY,
+  COALESCE,
   SUPER,
   THIS,
   TRUE,
@@ -328,13 +329,15 @@ export abstract class Node {
     expression: Expression,
     typeArgs: TypeNode[] | null,
     args: Expression[],
+    isOptionalChaining: bool,
     range: Range
   ): CallExpression {
     var expr = new CallExpression();
     expr.range = range;
     expr.expression = expression;
     expr.typeArguments = typeArgs;
     expr.arguments = args;
+    expr.isOptionalChaining = isOptionalChaining;
     return expr;
   }
 
@@ -368,12 +371,14 @@ export abstract class Node {
   static createElementAccessExpression(
     expression: Expression,
     element: Expression,
+    isOptionalChaining: bool,
     range: Range
   ): ElementAccessExpression {
     var expr = new ElementAccessExpression();
     expr.range = range;
     expr.expression = expression;
     expr.elementExpression = element;
+    expr.isOptionalChaining = isOptionalChaining;
     return expr;
   }
 
@@ -448,6 +453,18 @@ export abstract class Node {
     return expr;
   }
 
+  static createCoalesceExpression(
+    ifThen: Expression,
+    ifElse: Expression,
+    range: Range
+  ): CoalesceExpression {
+    var expr = new CoalesceExpression();
+    expr.range = range;
+    expr.ifThen = ifThen;
+    expr.ifElse = ifElse;
+    return expr;
+  }
+
   static createObjectLiteralExpression(
     names: IdentifierExpression[],
     values: Expression[],
@@ -473,12 +490,14 @@ export abstract class Node {
   static createPropertyAccessExpression(
     expression: Expression,
     property: IdentifierExpression,
+    isOptionalChaining: bool,
     range: Range
   ): PropertyAccessExpression {
     var expr = new PropertyAccessExpression();
     expr.range = range;
     expr.expression = expression;
     expr.property = property;
+    expr.isOptionalChaining = isOptionalChaining;
     return expr;
   }
 
@@ -1387,6 +1406,8 @@ export class CallExpression extends Expression {
   typeArguments: TypeNode[] | null;
   /** Provided arguments. */
   arguments: Expression[];
+  /** Whether optional chaining is used between the expression and the signature. */
+  isOptionalChaining: bool;
 
   /** Gets the type arguments range for reporting. */
   get typeArgumentsRange(): Range {
@@ -1417,6 +1438,16 @@ export class ClassExpression extends Expression {
   declaration: ClassDeclaration;
 }
 
+/** Represents a nullish coalescing expression. */
+export class CoalesceExpression extends Expression {
+  kind = NodeKind.COALESCE;
+
+  /** Expression head checked for being nullish. */
+  ifThen: Expression;
+  /** Expression executed when `ifThen` is nullish. */
+  ifElse: Expression;
+}
+
 /** Represents a comma expression composed of multiple expressions. */
 export class CommaExpression extends Expression {
   kind = NodeKind.COMMA;
@@ -1440,6 +1471,8 @@ export class ElementAccessExpression extends Expression {
   expression: Expression;
   /** Element of the expression being accessed. */
   elementExpression: Expression;
+  /** Whether optional chaining is used between the expression and the access. */
+  isOptionalChaining: bool;
 }
 
 /** Represents a float literal expression. */
@@ -1514,6 +1547,8 @@ export class PropertyAccessExpression extends Expression {
   expression: Expression;
   /** Property of the expression being accessed. */
   property: IdentifierExpression;
+  /** Whether optional chaining is used between the expression and the property. */
+  isOptionalChaining: bool;
 }
 
 /** Represents a regular expression literal expression. */

diff --git a/src/common.ts b/src/common.ts
@@ -70,13 +70,11 @@ export enum CommonFlags {
   TRAMPOLINE = 1 << 25,
   /** Is a virtual method. */
   VIRTUAL = 1 << 26,
-  /** Is the main function. */
-  MAIN = 1 << 27,
 
   // Other
 
   /** Is quoted. */
-  QUOTED = 1 << 28
+  QUOTED = 1 << 27
 }
 
 /** Path delimiter inserted between file system levels. */
@@ -133,6 +131,7 @@ export namespace CommonSymbols {
   export const void_ = "void";
   export const number = "number";
   export const boolean = "boolean";
+  export const auto = "auto";
   export const string = "string";
   export const native = "native";
   export const indexof = "indexof";

diff --git a/src/compiler.ts b/src/compiler.ts
@@ -106,6 +106,7 @@ import {
   Range,
   DecoratorKind,
   AssertionKind,
+  SourceKind,
 
   Statement,
   BlockStatement,
@@ -135,6 +136,7 @@ import {
   WhileStatement,
 
   Expression,
+  ExportDefaultStatement,
   AssertionExpression,
   BinaryExpression,
   CallExpression,
@@ -151,16 +153,15 @@ import {
   ParenthesizedExpression,
   PropertyAccessExpression,
   TernaryExpression,
+  CoalesceExpression,
   ArrayLiteralExpression,
   StringLiteralExpression,
   UnaryPostfixExpression,
   UnaryPrefixExpression,
 
   nodeIsConstantValue,
   findDecorator,
-  isTypeOmitted,
-  ExportDefaultStatement,
-  SourceKind
+  isTypeOmitted
 } from "./ast";
 
 import {
@@ -1146,7 +1147,7 @@ export class Compiler extends DiagnosticEmitter {
       assert(instance.prototype.arrowKind);
 
       // none of the following can be an arrow function
-      assert(!instance.isAny(CommonFlags.CONSTRUCTOR | CommonFlags.GET | CommonFlags.SET | CommonFlags.MAIN));
+      assert(!instance.isAny(CommonFlags.CONSTRUCTOR | CommonFlags.GET | CommonFlags.SET));
 
       let expr = this.compileExpression((<ExpressionStatement>bodyNode).expression, returnType,
         Constraints.CONV_IMPLICIT
@@ -2849,6 +2850,10 @@ export class Compiler extends DiagnosticEmitter {
         expr = this.compileTernaryExpression(<TernaryExpression>expression, contextualType, constraints);
         break;
       }
+      case NodeKind.COALESCE: {
+        expr = this.compileCoalesceExpression(<CoalesceExpression>expression, contextualType, constraints);
+        break;
+      }
       case NodeKind.UNARYPOSTFIX: {
         expr = this.compileUnaryPostfixExpression(<UnaryPostfixExpression>expression, contextualType, constraints);
         break;
@@ -2892,9 +2897,13 @@ export class Compiler extends DiagnosticEmitter {
     contextualType: Type,
     constraints: Constraints = Constraints.NONE
   ): ExpressionRef {
-    return this.module.precomputeExpression(
-      this.compileExpression(expression, contextualType, constraints)
-    );
+    var orig = this.compileExpression(expression, contextualType, constraints);
+    var expr = this.module.precomputeExpression(orig);
+    if (orig != expr) {
+      let skippedAutoreleases = this.skippedAutoreleases;
+      if (skippedAutoreleases.has(orig)) skippedAutoreleases.add(expr);
+    }
+    return expr;
   }
 
   convertExpression(
@@ -5734,9 +5743,41 @@ export class Compiler extends DiagnosticEmitter {
 
     var module = this.module;
     var flow = this.currentFlow;
+    var targetExpression = expression.expression;
+
+    // TODO: In these cases we compile the target of an element or property
+    // access, but not the element or property access itself, essentially
+    // skipping over optional chaining.
+    switch (targetExpression.kind) {
+      case NodeKind.ELEMENTACCESS: {
+        if ((<ElementAccessExpression>targetExpression).isOptionalChaining) {
+          this.error(
+            DiagnosticCode.Not_implemented,
+            (<ElementAccessExpression>targetExpression).expression.range.atEnd
+          );
+        }
+        break;
+      }
+      case NodeKind.PROPERTYACCESS: {
+        if ((<PropertyAccessExpression>targetExpression).isOptionalChaining) {
+          this.error(
+            DiagnosticCode.Not_implemented,
+            (<PropertyAccessExpression>targetExpression).expression.range.atEnd
+          );
+        }
+        break;
+      }
+    }
+    // TODO
+    if (expression.isOptionalChaining) {
+      this.error(
+        DiagnosticCode.Not_implemented,
+        targetExpression.range.atEnd
+      );
+    }
 
     // handle call to super
-    if (expression.expression.kind == NodeKind.SUPER) {
+    if (targetExpression.kind == NodeKind.SUPER) {
       let flow = this.currentFlow;
       let actualFunction = flow.actualFunction;
       if (!actualFunction.is(CommonFlags.CONSTRUCTOR)) {
@@ -5793,7 +5834,7 @@ export class Compiler extends DiagnosticEmitter {
     }
 
     // otherwise resolve normally
-    var target = this.resolver.lookupExpression(expression.expression, flow); // reports
+    var target = this.resolver.lookupExpression(targetExpression, flow); // reports
     if (!target) return module.unreachable();
 
     var signature: Signature | null;
@@ -5817,7 +5858,7 @@ export class Compiler extends DiagnosticEmitter {
           if (!prototype.is(CommonFlags.GENERIC)) {
             this.error(
               DiagnosticCode.Type_0_is_not_generic,
-              expression.expression.range, prototype.internalName
+              targetExpression.range, prototype.internalName
             );
             return module.unreachable();
           }
@@ -5879,7 +5920,7 @@ export class Compiler extends DiagnosticEmitter {
             // invalid because the type is effectively unknown inside the function body
             this.error(
               DiagnosticCode.Type_argument_expected,
-              expression.expression.range.atEnd
+              targetExpression.range.atEnd
             );
             return this.module.unreachable();
           }
@@ -5962,15 +6003,15 @@ export class Compiler extends DiagnosticEmitter {
       }
       case ElementKind.FUNCTION_TARGET: {
         signature = (<FunctionTarget>target).signature;
-        indexArg = this.compileExpression(expression.expression, (<FunctionTarget>target).type, Constraints.CONV_IMPLICIT);
+        indexArg = this.compileExpression(targetExpression, (<FunctionTarget>target).type, Constraints.CONV_IMPLICIT);
         break;
       }
 
       case ElementKind.PROPERTY_PROTOTYPE: { // static property
         let getterPrototype = assert((<PropertyPrototype>target).getterPrototype);
         let getterInstance = this.resolver.resolveFunction(getterPrototype, null);
         if (!getterInstance) return module.unreachable();
-        indexArg = this.compileCallDirect(getterInstance, [], expression.expression);
+        indexArg = this.compileCallDirect(getterInstance, [], targetExpression);
         signature = this.currentType.signatureReference;
         if (!signature) {
           this.error(
@@ -5983,7 +6024,7 @@ export class Compiler extends DiagnosticEmitter {
       }
       case ElementKind.PROPERTY: { // instance property
         let getterInstance = assert((<Property>target).getterInstance);
-        indexArg = this.compileCallDirect(getterInstance, [], expression.expression,
+        indexArg = this.compileCallDirect(getterInstance, [], targetExpression,
           this.compileExpression(assert(this.resolver.currentThisExpression), this.options.usizeType)
         );
         signature = this.currentType.signatureReference;
@@ -6948,6 +6989,14 @@ export class Compiler extends DiagnosticEmitter {
     contextualType: Type,
     constraints: Constraints
   ): ExpressionRef {
+
+    if (expression.isOptionalChaining) {
+      this.error(
+        DiagnosticCode.Not_implemented,
+        expression.expression.range.atEnd
+      );
+    }
+
     var module = this.module;
     var targetExpression = expression.expression;
     var targetType = this.resolver.resolveExpression(targetExpression, this.currentFlow); // reports
@@ -7951,6 +8000,14 @@ export class Compiler extends DiagnosticEmitter {
     ctxType: Type,
     constraints: Constraints
   ): ExpressionRef {
+
+    if (expression.isOptionalChaining) {
+      this.error(
+        DiagnosticCode.Not_implemented,
+        expression.expression.range.atEnd
+      );
+    }
+
     var module = this.module;
     var flow = this.currentFlow;
 
@@ -8138,6 +8195,18 @@ export class Compiler extends DiagnosticEmitter {
     return expr;
   }
 
+  compileCoalesceExpression(
+    expression: CoalesceExpression,
+    ctxType: Type,
+    constraints: Constraints
+  ): ExpressionRef {
+    this.error(
+      DiagnosticCode.Not_implemented,
+      expression.range
+    );
+    return this.module.unreachable();
+  }
+
   compileUnaryPostfixExpression(
     expression: UnaryPostfixExpression,
     contextualType: Type,