Add Vector type to Kernel

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

 // Copyright (c) 2017, 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.rewriter;
 
 import '../../ast.dart';
 import 'converter.dart' show ClosureConverter;
 
 /// Used by the [Context] to initialize and update the context variable
 /// used to capture the variables closed over by functions.
 abstract class AstRewriter {
   /// The declared variable that holds the context.
   VariableDeclaration contextDeclaration;
 
   /// The expression used to initialize the size of the context stored in
   /// [contextDeclaration]. This expression is modified when the context is
   /// extended.
   IntLiteral contextSize;
 
   /// Creates a new [AstRewriter] for a (nested) [Block].
   BlockRewriter forNestedBlock(Block block);
 
   /// Inserts an allocation of a context and initializes [contextDeclaration]
   /// and [contextSize].
-  void insertContextDeclaration(Class contextClass, Expression accessParent);
+  void insertContextDeclaration(Expression accessParent);
 
-  /// Inserts an expression or statement that extends the context, where
-  /// [arguments] holds a pair of the new index and the initial value.
-  void insertExtendContext(Expression accessContext, Arguments arguments);
+  /// Inserts an expression or statement that extends the context.
+  void insertExtendContext(VectorSet extender);
 
-  void _createDeclaration(Class contextClass) {
+  void _createDeclaration() {
     assert(contextDeclaration == null && contextSize == null);
 
-    contextSize = new IntLiteral(0);
+    // [contextSize] is set to 1 initially, becauze the 0-th element of it works
+    // as a link to the parent context.
+    contextSize = new IntLiteral(1);
     contextDeclaration = new VariableDeclaration.forValue(
-        new ConstructorInvocation(contextClass.constructors.first,
-            new Arguments(<Expression>[contextSize])),
-        type: new InterfaceType(contextClass));
+        new VectorCreation(contextSize),
+        type: new VectorType());
     contextDeclaration.name = "#context";
   }
 }
 
 /// Adds a local variable for the context and adds update [Statement]s to the
 /// current block.
 class BlockRewriter extends AstRewriter {
   Block _currentBlock;
   int _insertionIndex;
 
@@ skipping 15 matching lines @@
         transformed.parent = _currentBlock;
       }
     }
   }
 
   void _insertStatement(Statement statement) {
     _currentBlock.statements.insert(_insertionIndex++, statement);
     statement.parent = _currentBlock;
   }
 
-  void insertContextDeclaration(Class contextClass, Expression accessParent) {
-    _createDeclaration(contextClass);
+  void insertContextDeclaration(Expression accessParent) {
+    _createDeclaration();
     _insertStatement(contextDeclaration);
     if (accessParent is! NullLiteral) {
-      _insertStatement(new ExpressionStatement(new PropertySet(
+      // Index 0 of a context always points to the parent.
+      _insertStatement(new ExpressionStatement(new VectorSet(
           new VariableGet(contextDeclaration),
-          new Name('parent'),
+          new IntLiteral(0),
           accessParent)));
     }
   }
 
-  void insertExtendContext(Expression accessContext, Arguments arguments) {
-    _insertStatement(new ExpressionStatement(
-        new MethodInvocation(accessContext, new Name('[]='), arguments)));
+  void insertExtendContext(VectorSet extender) {
+    _insertStatement(new ExpressionStatement(extender));
   }
 }
 
 /// Creates and updates the context as [Let] bindings around the initializer
 /// expression.
 class InitializerRewriter extends AstRewriter {
   final Expression initializingExpression;
 
   InitializerRewriter(this.initializingExpression) {
     assert(initializingExpression.parent is FieldInitializer);
   }
 
   @override
   BlockRewriter forNestedBlock(Block block) {
     return new BlockRewriter(block);
   }
 
   @override
-  void insertContextDeclaration(Class contextClass, Expression accessParent) {
-    _createDeclaration(contextClass);
+  void insertContextDeclaration(Expression accessParent) {
+    _createDeclaration();
     FieldInitializer parent = initializingExpression.parent;
     Let binding = new Let(contextDeclaration, initializingExpression);
     initializingExpression.parent = binding;
     parent.value = binding;
     binding.parent = parent;
   }
 
   @override
-  void insertExtendContext(Expression accessContext, Arguments arguments) {
-    Expression extendContext =
-        new MethodInvocation(accessContext, new Name('[]='), arguments);
+  void insertExtendContext(VectorSet extender) {
     Let parent = initializingExpression.parent;
-    Let binding = new Let(
-        new VariableDeclaration(null, initializer: extendContext),
+    Let binding = new Let(new VariableDeclaration(null, initializer: extender),
         initializingExpression);
     parent.body = binding;
     binding.parent = parent;
   }
 }