Allow closures inside lazy 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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 349 matching lines @@
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
-  void startFunction(FunctionElement function,
-                     FunctionExpression node) {
-    assert(invariant(node, function.isImplementation));
+  void startFunction(Element element, Expression node) {
+    assert(invariant(node, element.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
-            node, builder.elements);
-    FunctionSignature signature = function.computeSignature(compiler);
-    signature.orderedForEachParameter((Element element) {
-      HInstruction parameter = new HParameterValue(element);
-      builder.add(parameter);
-      builder.parameters[element] = parameter;
-      directLocals[element] = parameter;
-      parameter.guaranteedType =
-        builder.mapInferredType(typesTask.getGuaranteedTypeOfElement(element));
-    });
+            element, node, builder.elements);
+
+    if (element is FunctionElement) {
+      FunctionElement functionElement = element;
+      FunctionSignature params = functionElement.computeSignature(compiler);
+      params.orderedForEachParameter((Element parameterElement) {
+        HInstruction parameter = new HParameterValue(parameterElement);
+        builder.add(parameter);
+        builder.parameters[parameterElement] = parameter;
+        directLocals[parameterElement] = parameter;
+        parameter.guaranteedType =
+            builder.mapInferredType(
+                typesTask.getGuaranteedTypeOfElement(parameterElement));
+      });
+    }
 
     enterScope(node);
 
     // 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();
       builder.add(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
-    } else if (function.isInstanceMember()
-               || function.isGenerativeConstructor()) {
+    } else if (element.isInstanceMember()
+               || element.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
-      ClassElement cls = function.getEnclosingClass();
+      ClassElement cls = element.getEnclosingClass();
       DartType type = cls.computeType(builder.compiler);
       HInstruction thisInstruction = new HThis(new HBoundedType.nonNull(type));
       builder.add(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element !== null);
     assert(isAccessedDirectly(element));
@@ skipping 508 matching lines @@
     FunctionExpression function = functionElement.parseNode(compiler);
     assert(function !== null);
     assert(!function.modifiers.isExternal());
     assert(elements[function] !== null);
     openFunction(functionElement, function);
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
-    HBasicBlock block = graph.addNewBlock();
-    open(graph.entry);
-    close(new HGoto()).addSuccessor(block);
-    open(block);
     SendSet node = variable.parseNode(compiler);
+    openFunction(variable, node);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty() && link.tail.isEmpty());
     visit(link.head);
     HInstruction value = pop();
     value = potentiallyCheckType(value, variable);
     close(new HReturn(value)).addSuccessor(graph.exit);
-    graph.finalize();
-    return graph;
+    return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
     assert(constructor.isGenerativeConstructor());
@@ skipping 448 matching lines @@
     ClosureClassMap closureData = localsHandler.closureData;
     Element checkResultElement = closureData.parametersWithSentinel[element];
     localsHandler.updateLocal(checkResultElement, check);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be the implementation element.
    */
-  void openFunction(FunctionElement functionElement,
-                    FunctionExpression node) {
-    assert(invariant(functionElement, functionElement.isImplementation));
+  void openFunction(Element element, Expression node) {
+    assert(invariant(element, element.isImplementation));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
-    localsHandler.startFunction(functionElement, node);
+    localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
-    FunctionSignature params = functionElement.computeSignature(compiler);
-    params.orderedForEachParameter((Element element) {
-      if (elements.isParameterChecked(element)) {
-        addParameterCheckInstruction(element);
-      }
-    });
+    if (element is FunctionElement) {
+      FunctionElement functionElement = element;
+      FunctionSignature params = functionElement.computeSignature(compiler);
+      params.orderedForEachParameter((Element parameterElement) {
+        if (elements.isParameterChecked(parameterElement)) {
+          addParameterCheckInstruction(parameterElement);
+        }
+      });
 
-    // Put the type checks in the first successor of the entry,
-    // because that is where the type guards will also be inserted.
-    // This way we ensure that a type guard will dominate the type
-    // check.
-    params.orderedForEachParameter((Element element) {
-      HInstruction newParameter = potentiallyCheckType(
-          localsHandler.directLocals[element], element);
-      localsHandler.directLocals[element] = newParameter;
-    });
+      // Put the type checks in the first successor of the entry,
+      // because that is where the type guards will also be inserted.
+      // This way we ensure that a type guard will dominate the type
+      // check.
+      params.orderedForEachParameter((Element element) {
+        HInstruction newParameter = potentiallyCheckType(
+            localsHandler.directLocals[element], element);
+        localsHandler.directLocals[element] = newParameter;
+      });
+    } else {
+      // Otherwise it is a lazy initializer which does not have parameters.
+      assert(element is VariableElement);
+    }
 
     // Add the type parameters of the class as parameters of this
     // method.
-    var enclosing = functionElement.enclosingElement;
-    if (functionElement.isConstructor() && compiler.world.needsRti(enclosing)) {
+    var enclosing = element.enclosingElement;
+    if (element.isConstructor() && compiler.world.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param = new HParameterValue(typeVariable.element);
         add(param);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(
       HInstruction original, Element sourceElement,
@@ skipping 2998 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;
   }
 }