Support closures inside initializers.

lib/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 304 matching lines @@
                                     const LiteralDartString('Object'),
                                     <HInstruction>[]);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
-  void enterScope(Node node) {
+  void enterScope(Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData != null) {
-      // The scope has captured variables. Create a box.
-      // TODO(floitsch): Clean up this hack. Should we create a box-object by
-      // just creating an empty object literal?
-      HInstruction box = createBox();
+      HInstruction box;
+      // The scope has captured variables.
+      if (element != null && element.isGenerativeConstructorBody()) {
+        // The box is passed as a parameter to a generative
+        // constructor body.
+        box = new HParameterValue(scopeData.boxElement);
+        builder.add(box);
+      } else {
+        // TODO(floitsch): Clean up this hack. Should we create a box-object by
+        // just creating an empty object literal?
+        box = createBox();
+      }
       // Add the box to the known locals.
       directLocals[scopeData.boxElement] = box;
       // Make sure that accesses to the boxed locals go into the box. We also
       // need to make sure that parameters are copied into the box if necessary.
       scopeData.capturedVariableMapping.forEach((Element from, Element to) {
         // The [from] can only be a parameter for function-scopes and not
         // loop scopes.
         if (from.isParameter()) {
           // Store the captured parameter in the box. Get the current value
           // before we put the redirection in place.
@@ skipping 47 matching lines @@
         HInstruction parameter = new HParameterValue(parameterElement);
         builder.add(parameter);
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
         parameter.guaranteedType =
             builder.mapInferredType(
                 typesTask.getGuaranteedTypeOfElement(parameterElement));
       });
     }
 
-    enterScope(node);
+    enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure()) {
       // Inside closure redirect references to itself to [:this:].
       HInstruction thisInstruction = new HThis();
@@ skipping 191 matching lines @@
    *  loop-exit:
    */
   void startLoop(Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     if (scopeData.hasBoxedLoopVariables()) {
       // If there are boxed loop variables then we set up the box and
       // redirections already now. This way the initializer can write its
       // values into the box.
       // For other loops the box will be created when entering the body.
-      enterScope(node);
+      enterScope(node, null);
     }
   }
 
   void beginLoopHeader(Node node, HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over
     // it.
     Map<Element, HInstruction> saved =
         new Map<Element, HInstruction>.from(directLocals);
 
     // Create phis for all elements in the definitions environment.
@@ skipping 10 matching lines @@
       }
     });
   }
 
   void enterLoopBody(Node node) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     // If there are no declared boxed loop variables then we did not create the
     // box before the initializer and we have to create the box now.
     if (!scopeData.hasBoxedLoopVariables()) {
-      enterScope(node);
+      enterScope(node, null);
     }
   }
 
   void enterLoopUpdates(Loop node) {
     // If there are declared boxed loop variables then the updates might have
     // access to the box and we must switch to a new box before executing the
     // updates.
     // In all other cases a new box will be created when entering the body of
     // the next iteration.
     ClosureScope scopeData = closureData.capturingScopes[node];
@@ skipping 510 matching lines @@
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       TreeElements oldElements = elements;
       elements =
           compiler.enqueuer.resolution.getCachedElements(constructor);
 
       ClosureClassMap oldClosureData = localsHandler.closureData;
+      Node node = constructor.parseNode(compiler);
       localsHandler.closureData =
           compiler.closureToClassMapper.computeClosureToClassMapping(
-              constructor, constructor.parseNode(compiler), elements);
+              constructor, node, elements);
 
       params.orderedForEachParameter((Element parameterElement) {
         if (elements.isParameterChecked(parameterElement)) {
           addParameterCheckInstruction(parameterElement);
         }
       });
-
+      localsHandler.enterScope(node, constructor);
       buildInitializers(constructor, constructors, fieldValues);
       localsHandler.closureData = oldClosureData;
       elements = oldElements;
     });
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
@@ skipping 169 matching lines @@
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body == null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       FunctionSignature functionSignature = body.computeSignature(compiler);
       int arity = functionSignature.parameterCount;
       functionSignature.orderedForEachParameter((parameter) {
+        // TODO(ngeoffray): No need to pass the parameters that are
+        // captured and stored in a box. Because this information is
+        // not trivial to get in codegen.dart, we just pass the
+        // parameters anyway. We need to update both codegen.dart and
+        // builder.dart on how parameters are being passed.
         bodyCallInputs.add(localsHandler.readLocal(parameter));
       });
 
       // If parameters are checked, we pass the already computed
       // boolean to the constructor body.
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(constructor);
       Node node = constructor.parseNode(compiler);
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
       functionSignature.orderedForEachParameter((parameter) {
         if (elements.isParameterChecked(parameter)) {
           Element fieldCheck =
               parameterClosureData.parametersWithSentinel[parameter];
           bodyCallInputs.add(localsHandler.readLocal(fieldCheck));
         }
       });
 
+      // If there are locals that escape (ie used in closures), we
+      // pass the box to the constructor.
+      ClosureScope scopeData = parameterClosureData.capturingScopes[node];
+      if (scopeData != null) {
+        bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
+      }
+
       // TODO(ahe): The constructor name is statically resolved. See
       // SsaCodeGenerator.visitInvokeDynamicMethod. Is there a cleaner
       // way to do this?
       SourceString name =
           new SourceString(backend.namer.getName(body.declaration));
       // TODO(kasperl): This seems fishy. We shouldn't be inventing all
       // these selectors. Maybe the resolver can do more of the work
       // for us here?
       LibraryElement library = body.getLibrary();
       Selector selector = new Selector.call(name, library, arity);
@@ skipping 3184 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }