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 155 matching lines @@
       } else if (kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                  kind === ElementKind.FUNCTION ||
                  kind === ElementKind.GETTER ||
                  kind === ElementKind.SETTER) {
         graph = builder.buildMethod(work.element);
       } else if (kind === ElementKind.FIELD) {
         graph = builder.buildLazyInitializer(work.element);
       }
       assert(graph.isValid());
       if (kind !== ElementKind.FIELD) {
+        FunctionElement functionElement = element;
         bool inLoop = functionsCalledInLoop.contains(element);
         if (!inLoop) {
           Selector selector = selectorsCalledInLoop[element.name];
           inLoop = selector !== null && selector.applies(element, compiler);
         }
         graph.calledInLoop = inLoop;
 
         // If there is an estimate of the parameter types assume these types when

[kasperl, 2012/09/10 13:44:29]

Long line. NYF.

[floitsch, 2012/10/09 16:06:44]

Has been fixed in the mean-time.

         // compiling.
         OptionalParameterTypes defaultValueTypes = null;
-        FunctionSignature signature = element.computeSignature(compiler);
+        FunctionSignature signature =
+            functionElement.computeSignature(compiler);
         if (signature.optionalParameterCount > 0) {
           defaultValueTypes =
               new OptionalParameterTypes(signature.optionalParameterCount);
           int index = 0;
           signature.forEachOptionalParameter((Element parameter) {
             Constant defaultValue = compiler.compileVariable(parameter);
             HType type = HGraph.mapConstantTypeToSsaType(defaultValue);
             defaultValueTypes.update(index, parameter.name, type);
             index++;
           });
@@ skipping 136 matching lines @@
       // [readLocal] uses the [boxElement] to find its box. By replacing it
       // behind its back we can still get to the old values.
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
-  void startFunction(FunctionElement function,
-                     FunctionExpression node) {
+  void startFunction(Element element, Expression node) {
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
-            node, builder.elements);
-    FunctionSignature signature = function.computeSignature(compiler);
-    signature.forEachParameter((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.forEachParameter((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 496 matching lines @@
   }
 
   HGraph buildMethod(FunctionElement functionElement) {
     FunctionExpression function = functionElement.parseNode(compiler);
     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);
     close(new HReturn(pop())).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 392 matching lines @@
 
     // Create the instruction that parameter checks will use.
     check = new HNot(check);
     add(check);
 
     ClosureClassMap closureData = localsHandler.closureData;
     Element checkResultElement = closureData.parametersWithSentinel[element];
     localsHandler.updateLocal(checkResultElement, check);
   }
 
-  void openFunction(FunctionElement functionElement,
-                    FunctionExpression node) {
+  void openFunction(Element element, Expression node) {
     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.forEachParameter((Element element) {
-      if (elements.isParameterChecked(element)) {
-        addParameterCheckInstruction(element);
-      }
-    });
+    if (element is FunctionElement) {
+      FunctionElement functionElement = element;
+      FunctionSignature params = functionElement.computeSignature(compiler);
+      params.forEachParameter((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.forEachParameter((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.forEachParameter((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.
-    if (functionElement.isFactoryConstructor()
-        || functionElement.isGenerativeConstructor()) {
-      ClassElement cls = functionElement.enclosingElement;
+    if (element.isFactoryConstructor()
+        || element.isGenerativeConstructor()) {
+      ClassElement cls = element.enclosingElement;
       cls.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param = new HParameterValue(typeVariable.element);
         add(param);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
@@ skipping 1352 matching lines @@
     Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  [Link<Node> argumentNodes,
                                   List<HInstruction> argumentValues]) {
     Element helper =
         compiler.findHelper(const SourceString('throwNoSuchMethod'));
-    Constant receiverConstant = 
+    Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
     HInstruction name = graph.addConstant(nameConstant);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
@@ skipping 1341 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;
   }
 }