Add Vector type to Kernel

pkg/kernel/lib/transformations/closure/converter.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.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
@@ skipping 34 matching lines @@
         StringLiteral,
         Supertype,
         ThisExpression,
         Transformer,
         TreeNode,
         TypeParameter,
         TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VariableSet,
+        VectorType,
         transformList;
 
 import '../../frontend/accessors.dart' show VariableAccessor;
 
 import '../../clone.dart' show CloneVisitor;
 
 import '../../core_types.dart' show CoreTypes;
 
 import '../../type_algebra.dart' show substitute;
 
@@ skipping 191 matching lines @@
     FunctionNode enclosingFunction = currentFunction;
     Map<TypeParameter, DartType> enclosingTypeSubstitution = typeSubstitution;
     currentFunction = function;
     Statement body = function.body;
     assert(body != null);
 
     rewriter = makeRewriterForBody(function);
 
     VariableDeclaration contextVariable = new VariableDeclaration(
         "#contextParameter",
-        type: contextClass.rawType,
+        type: const VectorType(),
         isFinal: true);
     Context parent = context;
     context = context.toNestedContext(new VariableAccessor(contextVariable));
 
     Set<TypeParameter> captured = capturedTypeVariables[currentFunction];
     if (captured != null) {
       typeSubstitution = copyTypeVariables(captured);
     } else {
       typeSubstitution = const <TypeParameter, DartType>{};
     }
@@ skipping 30 matching lines @@
 
   TreeNode visitFunctionExpression(FunctionExpression node) {
     return saveContext(() {
       return handleLocalFunction(node.function);
     });
   }
 
   /// Add a new class to the current library that looks like this:
   ///
   ///     class Closure#0 extends core::Object implements core::Function {
-  ///       field _in::Context context;
-  ///       constructor •(final _in::Context #t1) → dynamic
-  ///         : self::Closure 0::context = #t1
+  ///       field Vector context;
+  ///       constructor •(final Vector #t1) → dynamic
+  ///         : self::Closure#0::context = #t1
   ///         ;
   ///       method call(/* The parameters of [function] */) → dynamic {
   ///         /// #t2 is [contextVariable].
-  ///         final _in::Context #t2 = this.{self::Closure#0::context};
+  ///         final Vector #t2 = this.{self::Closure#0::context};
   ///         /* The body of [function]. */
   ///       }
   ///     }
   ///
   /// Returns a constructor call to invoke the above constructor.
   ///
   /// TODO(ahe): We shouldn't create a class for each closure. Instead we turn
   /// [function] into a top-level function and use the Dart VM's mechnism for
   /// closures.
   Expression addClosure(
       FunctionNode function,
       VariableDeclaration contextVariable,
       Expression accessContext,
       Map<TypeParameter, DartType> substitution,
       Map<TypeParameter, DartType> enclosingTypeSubstitution) {
     Field contextField = new Field(
         // TODO(ahe): Rename to #context.
         new Name("context"),
-        type: contextClass.rawType,
+        type: const VectorType(),
         fileUri: currentFileUri);
     Class closureClass = createClosureClass(function,
         fields: [contextField], substitution: substitution);
     closureClass.addMember(new Procedure(
         new Name("call"), ProcedureKind.Method, function,
         fileUri: currentFileUri));
     newLibraryMembers.add(closureClass);
     Statement note = new ExpressionStatement(
         new StringLiteral("This is a temporary solution. "
             "In the VM, this will become an additional parameter."));
@@ skipping 480 matching lines @@
   // TODO(ahe): Remove this method when we don't generate closure classes
   // anymore.
   void addClosureClassNote(Class closureClass) {
     closureClass.addMember(new Field(new Name("note"),
         type: coreTypes.stringClass.rawType,
         initializer: new StringLiteral(
             "This is temporary. The VM doesn't need closure classes."),
         fileUri: currentFileUri));
   }
 }