Add Vector type to Kernel

pkg/kernel/lib/transformations/closure/context.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library kernel.transformations.closure.context;
 
 import '../../ast.dart'
     show
         Arguments,
         Class,
         Expression,
         IntLiteral,
         MethodInvocation,
         Name,
         NullLiteral,
         PropertyGet,
         StringLiteral,
         Throw,
         VariableDeclaration,
         VariableGet,
-        VariableSet;
+        VariableSet,
+        VectorGet,
+        VectorSet,
+        VectorCopy;
 
-import '../../frontend/accessors.dart'
-    show Accessor, IndexAccessor, VariableAccessor;
+import '../../frontend/accessors.dart' show Accessor, VariableAccessor;
 
 import 'converter.dart' show ClosureConverter;
 
 abstract class Context {
   /// Returns a new expression for accessing this context.
   Expression get expression;
 
   /// Returns an accessor (or null) for accessing this context.
   Accessor get accessor;
 
@@ skipping 68 matching lines @@
         converter, accessor, <List<VariableDeclaration>>[]);
   }
 }
 
 class LocalContext extends Context {
   final ClosureConverter converter;
   final Context parent;
   final VariableDeclaration self;
   final IntLiteral size;
   final List<VariableDeclaration> variables = <VariableDeclaration>[];
-  final Map<VariableDeclaration, Arguments> initializers =
-      <VariableDeclaration, Arguments>{};
+  final Map<VariableDeclaration, VectorSet> initializers =
+      <VariableDeclaration, VectorSet>{};
 
   LocalContext._internal(this.converter, this.parent, this.self, this.size);
 
   factory LocalContext(ClosureConverter converter, Context parent) {
     Class contextClass = converter.contextClass;
     assert(contextClass.constructors.length == 1);
-    converter.rewriter
-        .insertContextDeclaration(contextClass, parent.expression);
+    converter.rewriter.insertContextDeclaration(parent.expression);
 
     return new LocalContext._internal(converter, parent,
         converter.rewriter.contextDeclaration, converter.rewriter.contextSize);
   }
 
   Expression get expression => accessor.buildSimpleRead();
 
   Accessor get accessor => new VariableAccessor(self);
 
   void extend(VariableDeclaration variable, Expression value) {
-    Arguments arguments =
-        new Arguments(<Expression>[new IntLiteral(variables.length), value]);
-    converter.rewriter.insertExtendContext(expression, arguments);
+    // Increase index by 1, because the parent occupies item 0, and all other
+    // variables are therefore shifted by 1.
+    IntLiteral index = new IntLiteral(variables.length + 1);
+    VectorSet initializer = new VectorSet(expression, index, value);
+    index.parent = initializer;
+    value.parent = initializer;
+
+    converter.rewriter.insertExtendContext(initializer);
     ++size.value;
     variables.add(variable);
-    initializers[variable] = arguments;
+    initializers[variable] = initializer;
   }
 
   void update(VariableDeclaration variable, Expression value) {
-    Arguments arguments = initializers[variable];
-    arguments.positional[1] = value;
-    value.parent = arguments;
+    VectorSet initializer = initializers[variable];
+    initializer.value = value;
+    value.parent = initializer;
   }
 
   Expression lookup(VariableDeclaration variable) {
     var index = variables.indexOf(variable);
+    // Increase index by 1 in case of success, because the parent occupies
+    // item 0, and all other variables are therefore shifted by 1.
     return index == -1
         ? parent.lookup(variable)
-        : new MethodInvocation(expression, new Name('[]'),
-            new Arguments(<Expression>[new IntLiteral(index)]));
+        : new VectorGet(expression, new IntLiteral(index + 1));
   }
 
   Expression assign(VariableDeclaration variable, Expression value,
       {bool voidContext: false}) {
     var index = variables.indexOf(variable);
+    // Increase index by 1 in case of success, because the parent occupies
+    // item 0, and all other variables are therefore shifted by 1.
     return index == -1
         ? parent.assign(variable, value, voidContext: voidContext)
-        : IndexAccessor
-            .make(expression, new IntLiteral(index), null, null)
-            .buildAssignment(value, voidContext: voidContext);
+        : new VectorSet(expression, new IntLiteral(index + 1), value);
   }
 
   Context toNestedContext([Accessor accessor]) {
     accessor ??= this.accessor;
     List<List<VariableDeclaration>> variabless = <List<VariableDeclaration>>[];
     var current = this;
     while (current != null && current is! NoContext) {
       if (current is LocalContext) {
         variabless.add(current.variables);
         current = current.parent;
       } else if (current is NestedContext) {
         variabless.addAll((current as NestedContext).variabless);
         current = null;
       }
     }
     return new NestedContext(converter, accessor, variabless);
   }
 
   Expression clone() {
     self.isFinal = false;
-    return new VariableSet(
-        self,
-        new MethodInvocation(
-            new VariableGet(self), new Name("copy"), new Arguments.empty()));
+    return new VariableSet(self, new VectorCopy(new VariableGet(self)));
   }
 }
 
 class NestedContext extends Context {
   final ClosureConverter converter;
   final Accessor accessor;
   final List<List<VariableDeclaration>> variabless;
 
   NestedContext(this.converter, this.accessor, this.variabless);
 
   Expression get expression {
     return accessor?.buildSimpleRead() ?? new NullLiteral();
   }
 
   void extend(VariableDeclaration variable, Expression value) {
     converter.context = new LocalContext(converter, this)
       ..extend(variable, value);
   }
 
   Expression lookup(VariableDeclaration variable) {
     Expression context = expression;
     for (var variables in variabless) {
       var index = variables.indexOf(variable);
       if (index != -1) {
-        return new MethodInvocation(context, new Name('[]'),
-            new Arguments(<Expression>[new IntLiteral(index)]));
+        // Increase index by 1, because the parent occupies item 0, and all
+        // other variables are therefore shifted by 1.
+        return new VectorGet(context, new IntLiteral(index + 1));
       }
-      context = new PropertyGet(context, new Name('parent'));
+      // Item 0 of a context always points to its parent.
+      context = new VectorGet(context, new IntLiteral(0));
     }
     throw 'Unbound NestedContext.lookup($variable)';
   }
 
   Expression assign(VariableDeclaration variable, Expression value,
       {bool voidContext: false}) {
     Expression context = expression;
     for (List<VariableDeclaration> variables in variabless) {
       var index = variables.indexOf(variable);
       if (index != -1) {
-        return IndexAccessor
-            .make(context, new IntLiteral(index), null, null)
-            .buildAssignment(value, voidContext: voidContext);
+        // Increase index by 1, because the parent occupies item 0, and all
+        // other variables are therefore shifted by 1.
+        return new VectorSet(context, new IntLiteral(index + 1), value);
       }
-      context = new PropertyGet(context, new Name('parent'));
+      // Item 0 of a context always points to its parent.
+      context = new VectorGet(context, new IntLiteral(0));
     }
     throw 'Unbound NestedContext.lookup($variable)';
   }
 
   Context toNestedContext([Accessor accessor]) {
     return new NestedContext(converter, accessor ?? this.accessor, variabless);
   }
 }