Implement Array Destructuring [WIP]

src/ast.ts

@@ -274,9 +274,10 @@ export abstract class Node {
   static createElementAccessExpression(
     expression: Expression,
     elementExpression: Expression,
-    range: Range
+    range: Range,
+    expressionRefCacheKey: string | null
   ): ElementAccessExpression {
-    return new ElementAccessExpression(expression, elementExpression, range);
+    return new ElementAccessExpression(expression, elementExpression, range, expressionRefCacheKey);
   }
 
   static createFalseExpression(
@@ -721,6 +722,13 @@ export abstract class Node {
     return new VariableStatement(decorators, declarations, range);
   }
 
+  static createDestructedVariableStatement(
+    decorators: DecoratorNode[] | null,
+    declarations: VariableDeclaration[],
+  ): VariableStatement {
+    return new VariableStatement(decorators, declarations, new Range(-1, -1));
+  }
+
   static createVariableDeclaration(
     name: IdentifierExpression,
     decorators: DecoratorNode[] | null,
@@ -1267,7 +1275,9 @@ export class ElementAccessExpression extends Expression {
     /** Element of the expression being accessed. */
     public elementExpression: Expression,
     /** Source range. */
-    range: Range
+    range: Range,
+    /** Key to cache the expressionRef */
+    public expressionRefCacheKey: string | null
   ) {
     super(NodeKind.ELEMENTACCESS, range);
   }

src/compiler.ts

@@ -7340,13 +7340,33 @@ export class Compiler extends DiagnosticEmitter {
     return this.module.flatten(exprs, this.currentType.toNativeType());
   }
 
+  private compileExpressionMaybeCached (targetExpression: Expression, type: Type, expressionRefCacheKey: string | null) {
+    if(expressionRefCacheKey !== null) {
+      var cachedValue = this.currentFlow.getScopedLocal(expressionRefCacheKey);
+      if(cachedValue === null) {
+        var expressionRef = this.currentFlow.addScopedDummyLocalWithIntegerValue(
+          expressionRefCacheKey,
+          type,
+          i64_new(this.compileExpression(targetExpression, type, Constraints.CONV_IMPLICIT))
+        ).constantIntegerValue;
+        return Number(
+          expressionRef
+        );
+      } else {
+        return Number(cachedValue.constantIntegerValue);
+      }
+    }
+    return this.compileExpression(targetExpression, type, Constraints.CONV_IMPLICIT);
+  }
+
   private compileElementAccessExpression(
     expression: ElementAccessExpression,
     contextualType: Type,
     constraints: Constraints
   ): ExpressionRef {
     var module = this.module;
     var targetExpression = expression.expression;
+    var expressionRefCacheKey = expression.expressionRefCacheKey;
     var targetType = this.resolver.resolveExpression(targetExpression, this.currentFlow); // reports
     if (targetType) {
       let classReference = targetType.getClassOrWrapper(this.program);
@@ -7355,9 +7375,7 @@ export class Compiler extends DiagnosticEmitter {
         let indexedGet = classReference.lookupOverload(OperatorKind.INDEXED_GET, isUnchecked);
         if (indexedGet) {
           let thisType = assert(indexedGet.signature.thisType);
-          let thisArg = this.compileExpression(targetExpression, thisType,
-            Constraints.CONV_IMPLICIT
-          );
+          let thisArg = this.compileExpressionMaybeCached(targetExpression, thisType, expressionRefCacheKey);
           if (!isUnchecked && this.options.pedantic) {
             this.pedantic(
               DiagnosticCode.Indexed_access_may_involve_bounds_checking,

src/flow.ts

@@ -452,6 +452,13 @@ export class Flow {
     return scopedDummy;
   }
 
+  /** Adds a new scoped dummy local of the specified name and initiate a integer value. */
+  addScopedDummyLocalWithIntegerValue(name: string, type: Type, integerValue: i64): Local {
+    var local = this.addScopedLocal(name,type);
+    local.setConstantIntegerValue(integerValue, type);
+    return local;
+  }
+
   /** Adds a new scoped alias for the specified local. For example `super` aliased to the `this` local. */
   addScopedAlias(name: string, type: Type, index: i32, reportNode: Node | null = null): Local {
     var scopedLocals = this.scopedLocals;
@@ -912,7 +919,7 @@ export class Flow {
         let key = _keys[i];
         let leftFlags = changetype<FieldFlags>(leftFieldFlags.get(key));
         if (
-          (leftFlags & FieldFlags.INITIALIZED) != 0 && rightFieldFlags.has(key) && 
+          (leftFlags & FieldFlags.INITIALIZED) != 0 && rightFieldFlags.has(key) &&
           (changetype<FieldFlags>(rightFieldFlags.get(key)) & FieldFlags.INITIALIZED)
         ) {
           newFieldFlags.set(key, FieldFlags.INITIALIZED);

src/parser.ts

@@ -6,7 +6,6 @@
  *
  * @license Apache-2.0
  */
-
 import {
   CommonFlags,
   LIBRARY_PREFIX,
@@ -901,6 +900,51 @@ export class Parser extends DiagnosticEmitter {
     return null;
   }
 
+  parseDestructedVariableDeclaration(
+    tn: Tokenizer,
+    flags: CommonFlags,
+    decorators: DecoratorNode[] | null,
+    startPos: i32,
+    isFor: bool = false
+  ): VariableStatement | null {
+    var declarations = new Array<VariableDeclaration>();
+    if(!tn.skip(Token.OPENBRACKET)) {
+      return null;
+    }
+    do {
+      const declaration = this.parseVariableDeclaration(tn, flags, decorators, isFor, true);
+      if(declaration) {
+        declarations.push(declaration);
+      } else {
+        throw new Error("Failed to get declaration");
+      }
+    } while (tn.skip(Token.COMMA));
+    if(!tn.skip(Token.CLOSEBRACKET)){
+      throw new Error("Destructuring must end with a closing bracket");
+    }
+    if(tn.skip(Token.EQUALS)) {
+      let expression = this.parseExpression(tn);
+      if(!expression) return null;
+      expression = this.maybeParseCallExpression(tn, expression);
+      var expressionRefCacheKey = expression.kind === NodeKind.CALL ?
+        "_" + ((expression as CallExpression).expression as IdentifierExpression).text : null;
+
+      for(let index = 0; index < declarations.length; index++) {
+        var declaration = declarations[index];
+        var arrayIndexExpression = Node.createIntegerLiteralExpression(i64_new(index), tn.range());
+        declaration.initializer = Node.createElementAccessExpression(
+          expression,
+          arrayIndexExpression,
+          tn.range(startPos, tn.pos),
+          expressionRefCacheKey
+        );
+      }
+      return Node.createDestructedVariableStatement(decorators, declarations);
+    } else {
+      throw new Error("RHS does not include =");
+    }
+  }
+
   parseVariable(
     tn: Tokenizer,
     flags: CommonFlags,
@@ -912,13 +956,18 @@ export class Parser extends DiagnosticEmitter {
     // at ('const' | 'let' | 'var'): VariableDeclaration (',' VariableDeclaration)* ';'?
 
     var declarations = new Array<VariableDeclaration>();
-    do {
-      let declaration = this.parseVariableDeclaration(tn, flags, decorators, isFor);
-      if (!declaration) return null;
-      declarations.push(declaration);
-    } while (tn.skip(Token.COMMA));
+    var ret = null;
+    if(tn.peek() == Token.OPENBRACKET && !isFor) {
+      ret = this.parseDestructedVariableDeclaration(tn, flags, decorators, startPos, isFor);
+    } else {
+      do {
+        let declaration = this.parseVariableDeclaration(tn, flags, decorators, isFor);
+        if (!declaration) return null;
+        declarations.push(declaration);
+      } while (tn.skip(Token.COMMA));
+      ret = Node.createVariableStatement(decorators, declarations, tn.range(startPos, tn.pos));
+    }
 
-    var ret = Node.createVariableStatement(decorators, declarations, tn.range(startPos, tn.pos));
     tn.skip(Token.SEMICOLON);
     return ret;
   }
@@ -927,11 +976,14 @@ export class Parser extends DiagnosticEmitter {
     tn: Tokenizer,
     parentFlags: CommonFlags,
     parentDecorators: DecoratorNode[] | null,
-    isFor: bool = false
+    isFor: bool = false,
+    skipInitializer: boolean = false
   ): VariableDeclaration | null {
 
     // before: Identifier (':' Type)? ('=' Expression)?
-
+    if(tn.peek() == Token.OPENBRACKET) {
+      return null;
+    }
     if (!tn.skipIdentifier()) {
       this.error(
         DiagnosticCode.Identifier_expected,
@@ -965,10 +1017,10 @@ export class Parser extends DiagnosticEmitter {
         ); // recoverable
       }
       initializer = this.parseExpression(tn, Precedence.COMMA + 1);
-      if (!initializer) return null;
+      if (!initializer && !skipInitializer) return null;
     } else if (!isFor) {
       if (flags & CommonFlags.CONST) {
-        if (!(flags & CommonFlags.AMBIENT)) {
+        if (!skipInitializer && !(flags & CommonFlags.AMBIENT)) {
           this.error(
             DiagnosticCode._const_declarations_must_be_initialized,
             identifier.range
@@ -982,7 +1034,7 @@ export class Parser extends DiagnosticEmitter {
       }
     }
     var range = Range.join(identifier.range, tn.range());
-    if (initializer !== null && (flags & CommonFlags.DEFINITELY_ASSIGNED) != 0) {
+    if (!skipInitializer && initializer !== null && (flags & CommonFlags.DEFINITELY_ASSIGNED) != 0) {
       this.error(
         DiagnosticCode.A_definite_assignment_assertion_is_not_permitted_in_this_context,
         range
@@ -3996,7 +4048,8 @@ export class Parser extends DiagnosticEmitter {
           expr = Node.createElementAccessExpression(
             expr,
             next,
-            tn.range(startPos, tn.pos)
+            tn.range(startPos, tn.pos),
+            null
           );
           expr = this.maybeParseCallExpression(tn, expr);
           break;

src/util/text.ts

@@ -405,3 +405,14 @@ export function indent(sb: string[], level: i32): void {
     sb.push(indentX1);
   }
 }
+
+
+export function randomId(): string {
+  var size = 10;
+  var key = "";
+  var characters = 'abcdefghijklmnopqrstuvwxyz';
+  for (var i = 0; i < size; i++ ) {
+    key += characters.charAt(Math.floor(Math.random() * 26));
+  }
+  return  key;
+}