Allow closures inside lazy initializers.

lib/compiler/implementation/closure.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.
 
 #library("closureToClassMapper");
 
 #import("elements/elements.dart");
 #import("leg.dart");
 #import("scanner/scannerlib.dart");
 #import("tree/tree.dart");
 #import("util/util.dart");
 
 class ClosureTask extends CompilerTask {
   Map<Node, ClosureClassMap> closureMappingCache;
   ClosureTask(Compiler compiler)
       : closureMappingCache = new Map<Node, ClosureClassMap>(),
         super(compiler);
 
   String get name => "Closure Simplifier";
 
-  ClosureClassMap computeClosureToClassMapping(FunctionExpression node,
+  ClosureClassMap computeClosureToClassMapping(Element element,
+                                               Expression node,
                                                TreeElements elements) {
     return measure(() {
       ClosureClassMap cached = closureMappingCache[node];
       if (cached !== null) return cached;
 
       ClosureTranslator translator =
           new ClosureTranslator(compiler, elements, closureMappingCache);
+
       // The translator will store the computed closure-mappings inside the
-      // cache. One for given method and one for each nested closure.
-      translator.translate(node);
+      // cache. One for given node and one for each nested closure.
+      if (node is FunctionExpression) {
+        translator.translateFunction(element, node);
+      } else {
+        // Must be the lazy initializer of a static.
+        assert(node is SendSet);
+        translator.translateLazyInitializer(element, node);
+      }
       assert(closureMappingCache[node] != null);
       return closureMappingCache[node];
     });
   }
 
   ClosureClassMap getMappingForNestedFunction(FunctionExpression node) {
     return measure(() {
       ClosureClassMap nestedClosureData = closureMappingCache[node];
       if (nestedClosureData === null) {
         // TODO(floitsch): we can only assume that the reason for not having a
@@ skipping 64 matching lines @@
   List<Element> boxedLoopVariables;
 
   ClosureScope(this.boxElement, this.capturedVariableMapping)
       : boxedLoopVariables = const <Element>[];
 
   bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty();
 }
 
 class ClosureClassMap {
   // The closure's element before any translation. Will be null for methods.
-  final FunctionElement closureElement;
+  final Element closureElement;
   // The closureClassElement will be null for methods that are not local
   // closures.
   final ClassElement closureClassElement;
   // The callElement will be null for methods that are not local closures.
   final FunctionElement callElement;
   // The [thisElement] makes handling 'this' easier by treating it like any
   // other argument. It is only set for instance-members.
   final ThisElement thisElement;
 
   // Maps free locals, arguments and function elements to their captured
@@ skipping 36 matching lines @@
   final TreeElements elements;
   int closureFieldCounter = 0;
   bool inTryStatement = false;
   final Map<Node, ClosureClassMap> closureMappingCache;
 
   // Map of captured variables. Initially they will map to themselves. If
   // a variable needs to be boxed then the scope declaring the variable
   // will update this mapping.
   Map<Element, Element> capturedVariableMapping;
   // List of encountered closures.
-  List<FunctionExpression> closures;
+  List<Expression> closures;
 
   // The variables that have been declared in the current scope.
   List<Element> scopeVariables;
 
   // Keep track of the mutated variables so that we don't need to box
   // non-mutated variables.
   Set<Element> mutatedVariables;
 
-  FunctionElement outermostFunctionElement;
-  FunctionElement currentFunctionElement;
+  Element outermostElement;
+  Element currentElement;
 
   // The closureData of the currentFunctionElement.
   ClosureClassMap closureData;
 
   bool insideClosure = false;
 
   ClosureTranslator(this.compiler, this.elements, this.closureMappingCache)
       : capturedVariableMapping = new Map<Element, Element>(),
-        closures = <FunctionExpression>[],
+        closures = <Expression>[],
         mutatedVariables = new Set<Element>();
 
-  void translate(Node node) {
-    visit(node);
+  void translateFunction(Element element, FunctionExpression node) {
+    // For constructors the [element] and the [:elements[node]:] may differ.
+    // The [:elements[node]:] always points to the generative-constructor
+    // element, whereas the [element] might be the constructor-body element.
+    visit(node);  // [visitFunctionExpression] will call [visitInvokable].
     // When variables need to be boxed their [capturedVariableMapping] is
     // updated, but we delay updating the similar freeVariableMapping in the
     // closure datas that capture these variables.
     // The closures don't have their fields (in the closure class) set, either.
     updateClosures();
   }
 
+  void translateLazyInitializer(Element element, SendSet node) {
+    assert(node.assignmentOperator.source == const SourceString("="));
+    Expression initialValue = node.argumentsNode.nodes.head;
+    visitInvokable(element, node, () { visit(initialValue); });
+    updateClosures();
+  }
+
   // This function runs through all of the existing closures and updates their
   // free variables to the boxed value. It also adds the field-elements to the
   // class representing the closure. At the same time it fills the
   // [capturedFieldMapping].
   void updateClosures() {
-    for (FunctionExpression closure in closures) {
+    for (Expression closure in closures) {
       // The captured variables that need to be stored in a field of the closure
       // class.
       Set<Element> fieldCaptures = new Set<Element>();
       ClosureClassMap data = closureMappingCache[closure];
       Map<Element, Element> freeVariableMapping = data.freeVariableMapping;
       // We get a copy of the keys and iterate over it, to avoid modifications
       // to the map while iterating over it.
       freeVariableMapping.getKeys().forEach((Element fromElement) {
         assert(fromElement == freeVariableMapping[fromElement]);
         Element updatedElement = capturedVariableMapping[fromElement];
@@ skipping 33 matching lines @@
   }
 
   void useLocal(Element element) {
     // If the element is not declared in the current function and the element
     // is not the closure itself we need to mark the element as free variable.
     // Note that the check on [insideClosure] is not just an
     // optimization: factories have type parameters as function
     // parameters, and type parameters are declared in the class, not
     // the factory.
     if (insideClosure &&
-        element.enclosingElement != currentFunctionElement &&
-        element != currentFunctionElement) {
+        element.enclosingElement != currentElement &&
+        element != currentElement) {
       assert(closureData.freeVariableMapping[element] == null ||
              closureData.freeVariableMapping[element] == element);
       closureData.freeVariableMapping[element] = element;
     } else if (inTryStatement) {
       // Don't mark the this-element. This would complicate things in the
       // builder.
       if (element != closureData.thisElement) {
         // TODO(ngeoffray): only do this if the variable is mutated.
         closureData.usedVariablesInTry.add(element);
       }
@@ skipping 91 matching lines @@
     void analyzeTypeVariables(DartType type) {
       if (type is TypeVariableType) {
         useLocal(type.element);
       } else if (type is InterfaceType) {
         InterfaceType ifcType = type;
         for (DartType argument in ifcType.arguments) {
           analyzeTypeVariables(argument);
         }
       }
     }
-    if (outermostFunctionElement.isMember() &&
-        compiler.world.needsRti(outermostFunctionElement.getEnclosingClass())) {
-      if (outermostFunctionElement.isInstanceMember()
-          || outermostFunctionElement.isGenerativeConstructor()) {
+    if (outermostElement.isMember() &&
+        compiler.world.needsRti(outermostElement.getEnclosingClass())) {
+      if (outermostElement.isInstanceMember()
+          || outermostElement.isGenerativeConstructor()) {
         if (hasTypeVariable(type)) useLocal(closureData.thisElement);
-      } else if (outermostFunctionElement.isFactoryConstructor()) {
+      } else if (outermostElement.isFactoryConstructor()) {
         analyzeTypeVariables(type);
       }
     }
 
     node.visitChildren(this);
   }
 
   // If variables that are declared in the [node] scope are captured and need
   // to be boxed create a box-element and update the [capturingScopes] in the
   // current [closureData].
   // The boxed variables are updated in the [capturedVariableMapping].
   void attachCapturedScopeVariables(Node node) {
     Element box = null;
     Map<Element, Element> scopeMapping = new Map<Element, Element>();
     for (Element element in scopeVariables) {
       // No need to box non-assignable elements.
       if (!element.isAssignable()) continue;
       if (!mutatedVariables.contains(element)) continue;
       if (capturedVariableMapping.containsKey(element)) {
         if (box == null) {
           // TODO(floitsch): construct better box names.
           SourceString boxName =
               new SourceString("box_${closureFieldCounter++}");
-          box = new BoxElement(boxName, currentFunctionElement);
+          box = new BoxElement(boxName, currentElement);
         }
         // TODO(floitsch): construct better boxed names.
         String elementName = element.name.slowToString();
         // We are currently using the name in an HForeign which could replace
         // "$X" with something else.
         String escaped = elementName.replaceAll("\$", "_");
         SourceString boxedName =
             new SourceString("${escaped}_${closureFieldCounter++}");
         Element boxed = new Element(boxedName, ElementKind.FIELD, box);
         scopeMapping[element] = boxed;
@@ skipping 86 matching lines @@
                                  globalizedElement);
     globalizedElement.backendMembers =
         const EmptyLink<Element>().prepend(callElement);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     Element thisElement = closureData.thisElement;
     return new ClosureClassMap(element, globalizedElement,
                                callElement, thisElement);
   }
 
-  visitFunctionExpression(FunctionExpression node) {
-    Element element = elements[node];
-    if (element.isParameter()) {
-      // TODO(ahe): This is a hack. This method should *not* call
-      // visitChildren.
-      return node.name.accept(this);
-    }
-
+  void visitInvokable(Element element, Expression node, void visitChildren()) {
     bool oldInsideClosure = insideClosure;
-    FunctionElement oldFunctionElement = currentFunctionElement;
+    Element oldFunctionElement = currentElement;
     ClosureClassMap oldClosureData = closureData;
 
-    insideClosure = outermostFunctionElement != null;
-    currentFunctionElement = element;
+    insideClosure = outermostElement != null;
+    currentElement = element;
     if (insideClosure) {
       closures.add(node);
       closureData = globalizeClosure(node, element);
     } else {
-      outermostFunctionElement = element;
+      outermostElement = element;
       Element thisElement = null;
       if (element.isInstanceMember() || element.isGenerativeConstructor()) {
         thisElement = new ThisElement(element);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
     closureMappingCache[node] = closureData;
 
     inNewScope(node, () {
       // We have to declare the implicit 'this' parameter.
       if (!insideClosure && closureData.thisElement !== null) {
         declareLocal(closureData.thisElement);
       }
       // If we are inside a named closure we have to declare ourselve. For
       // simplicity we declare the local even if the closure does not have a
       // name.
       // It will simply not be used.
       if (insideClosure) {
         declareLocal(element);
       }
 
-      if (currentFunctionElement.isFactoryConstructor()
-          && compiler.world.needsRti(currentFunctionElement.enclosingElement)) {
+      if (currentElement.isFactoryConstructor()
+          && compiler.world.needsRti(currentElement.enclosingElement)) {
         // Declare the type parameters in the scope. Generative
         // constructors just use 'this'.
-        ClassElement cls = currentFunctionElement.enclosingElement;
+        ClassElement cls = currentElement.enclosingElement;
         cls.typeVariables.forEach((TypeVariableType typeVariable) {
           declareLocal(typeVariable.element);
         });
       }
 
-      // TODO(ahe): This is problematic. The backend should not repeat
-      // the work of the resolver. It is the resolver's job to create
-      // parameters, etc. Other phases should only visit statements.
-      // TODO(floitsch): we avoid visiting the initializers on purpose so that
-      // we get an error-message later in the builder.
-      if (node.parameters !== null) node.parameters.accept(this);
-      if (node.body !== null) node.body.accept(this);
+      visitChildren();
     });
 
 
     ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
-    currentFunctionElement = oldFunctionElement;
+    currentElement = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
     List<Element> freeVariables =
         savedClosureData.freeVariableMapping.getKeys();
     assert(freeVariables.isEmpty() || savedInsideClosure);
     for (Element freeElement in freeVariables) {
       if (capturedVariableMapping[freeElement] != null &&
           capturedVariableMapping[freeElement] != freeElement) {
         compiler.internalError('In closure analyzer', node: node);
       }
       capturedVariableMapping[freeElement] = freeElement;
       useLocal(freeElement);
     }
   }
 
+  visitFunctionExpression(FunctionExpression node) {
+    Element element = elements[node];
+
+    if (element.isParameter()) {
+      // TODO(ahe): This is a hack. This method should *not* call
+      // visitChildren.
+      return node.name.accept(this);
+    }
+
+    visitInvokable(element, node, () {
+      // TODO(ahe): This is problematic. The backend should not repeat
+      // the work of the resolver. It is the resolver's job to create
+      // parameters, etc. Other phases should only visit statements.
+      // TODO(floitsch): we avoid visiting the initializers on purpose so that
+      // we get an error-message later in the builder.
+      if (node.parameters !== null) node.parameters.accept(this);
+      if (node.body !== null) node.body.accept(this);
+    });
+  }
+
   visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     declareLocal(elements[node]);
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }