Revert "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(Element element, Expression node) {
-    assert(invariant(node, element.isImplementation));
+  void startFunction(FunctionElement function,
+                     FunctionExpression node) {
+    assert(invariant(node, function.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
-            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));
-      });
-    }
+            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));
+    });
 
     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 (element.isInstanceMember()
-               || element.isGenerativeConstructor()) {
+    } else if (function.isInstanceMember()
+               || function.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 = element.getEnclosingClass();
+      ClassElement cls = function.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);
-    return closeFunction();
+    graph.finalize();
+    return graph;
   }
 
   /**
    * 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(Element element, Expression node) {
-    assert(invariant(element, element.isImplementation));
+  void openFunction(FunctionElement functionElement,
+                    FunctionExpression node) {
+    assert(invariant(functionElement, functionElement.isImplementation));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
-    localsHandler.startFunction(element, node);
+    localsHandler.startFunction(functionElement, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
-    if (element is FunctionElement) {
-      FunctionElement functionElement = element;
-      FunctionSignature params = functionElement.computeSignature(compiler);
-      params.orderedForEachParameter((Element parameterElement) {
-        if (elements.isParameterChecked(parameterElement)) {
-          addParameterCheckInstruction(parameterElement);
-        }
-      });
+    FunctionSignature params = functionElement.computeSignature(compiler);
+    params.orderedForEachParameter((Element element) {
+      if (elements.isParameterChecked(element)) {
+        addParameterCheckInstruction(element);
+      }
+    });
 
-      // 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);
-    }
+    // 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;
+    });
 
     // Add the type parameters of the class as parameters of this
     // method.
-    var enclosing = element.enclosingElement;
-    if (element.isConstructor() && compiler.world.needsRti(enclosing)) {
+    var enclosing = functionElement.enclosingElement;
+    if (functionElement.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 2942 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;
   }
 }