closure conversion: Support closures in initializers

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,
-        ConstructorInvocation,
         Expression,
-        ExpressionStatement,
         IntLiteral,
-        InterfaceType,
         MethodInvocation,
         Name,
         NullLiteral,
         PropertyGet,
-        PropertySet,
         StringLiteral,
         Throw,
         VariableDeclaration,
         VariableGet,
         VariableSet;
 
 import '../../frontend/accessors.dart'
     show Accessor, IndexAccessor, VariableAccessor;
 
 import 'converter.dart' show ClosureConverter;
@@ skipping 84 matching lines @@
   final IntLiteral size;
   final List<VariableDeclaration> variables = <VariableDeclaration>[];
   final Map<VariableDeclaration, Arguments> initializers =
       <VariableDeclaration, Arguments>{};
 
   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);
-    IntLiteral zero = new IntLiteral(0);
-    VariableDeclaration declaration = new VariableDeclaration.forValue(
-        new ConstructorInvocation(
-            contextClass.constructors.first, new Arguments(<Expression>[zero])),
-        type: new InterfaceType(contextClass));
-    declaration.name = "#context";
-    converter.insert(declaration);
-    converter.insert(new ExpressionStatement(new PropertySet(
-        new VariableGet(declaration), new Name('parent'), parent.expression)));
+    converter.rewriter.insertContextDeclaration(
+        contextClass, parent.expression);
 
-    return new LocalContext._internal(converter, parent, declaration, zero);
+    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.insert(new ExpressionStatement(
-        new MethodInvocation(expression, new Name('[]='), arguments)));
+    converter.rewriter.insertExtendContext(expression, arguments);
     ++size.value;
     variables.add(variable);
     initializers[variable] = arguments;
   }
 
   void update(VariableDeclaration variable, Expression value) {
     Arguments arguments = initializers[variable];
     arguments.positional[1] = value;
     value.parent = arguments;
   }
@@ skipping 51 matching lines @@
   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) {
-    var context = expression;
+    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)]));
       }
       context = new PropertyGet(context, new Name('parent'));
     }
     throw 'Unbound NestedContext.lookup($variable)';
   }
 
   Expression assign(VariableDeclaration variable, Expression value,
       {bool voidContext: false}) {
-    var context = expression;
-    for (var variables in variabless) {
+    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);
       }
       context = new PropertyGet(context, new Name('parent'));
     }
     throw 'Unbound NestedContext.lookup($variable)';
   }
 
   Context toNestedContext([Accessor accessor]) {
     return new NestedContext(converter, accessor ?? this.accessor, variabless);
   }
 }