Make the closure-to-class translator more accessible. It can now be

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,
+                                                     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);
+      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
+        // closure data here is, because the function is inside an initializer.
+        compiler.unimplemented("Closures inside initializers", node: node);
+      }
+      return nestedClosureData;
+    });
+  }
+}
+
 class ClosureFieldElement extends Element {
   ClosureFieldElement(SourceString name, ClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   bool isInstanceMember() => true;
   bool isAssignable() => false;
 
   String toString() => "ClosureFieldElement($name)";
 }
 
@@ skipping 42 matching lines @@
   // declared in the initializer of the [For] and that need to be boxed.
   // Otherwise contains the empty List.
   List<Element> boxedLoopVariables;
 
   ClosureScope(this.boxElement, this.capturedVariableMapping)
       : boxedLoopVariables = const <Element>[];
 
   bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty();
 }
 
-class ClosureData {
+class ClosureClassMap {
   // The closure's element before any translation. Will be null for methods.
   final FunctionElement 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
   // copies.
   final Map<Element, Element> freeVariableMapping;
   // Maps closure-fields to their captured elements. This is somehow the inverse
   // mapping of [freeVariableMapping], but whereas [freeVariableMapping] does
   // not deal with boxes, here we map instance-fields (which might represent
   // boxes) to their boxElement.
   final Map<Element, Element> capturedFieldMapping;
 
   // Maps scopes ([Loop] and [FunctionExpression] nodes) to their
   // [ClosureScope] which contains their box and the
   // captured variables that are stored in the box.
   // This map will be empty if the method/closure of this [ClosureData] does not
   // contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes;
 
   final Set<Element> usedVariablesInTry;
 
-  ClosureData(this.closureElement,
+  ClosureClassMap(this.closureElement,
               this.closureClassElement,
               this.callElement,
               this.thisElement)
       : this.freeVariableMapping = new Map<Element, Element>(),
         this.capturedFieldMapping = new Map<Element, Element>(),
         this.capturingScopes = new Map<Node, ClosureScope>(),
         this.usedVariablesInTry = new Set<Element>();
 
   bool isClosure() => closureElement !== null;
 }
 
 class ClosureTranslator extends AbstractVisitor {
-  final SsaBuilder builder;
+  final Compiler compiler;
   final TreeElements elements;
   int closureFieldCounter = 0;
   bool inTryStatement = false;
-  final Map<Node, ClosureData> closureDataCache;
+  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;
 
   // 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 currentFunctionElement;
   // The closureData of the currentFunctionElement.
-  ClosureData closureData;
+  ClosureClassMap closureData;
 
   bool insideClosure = false;
 
-  Compiler get compiler() => builder.compiler;
+  ClosureTranslator(this.compiler, this.elements, this.closureMappingCache)
+      : capturedVariableMapping = new Map<Element, Element>(),
+        closures = <FunctionExpression>[],
+        mutatedVariables = new Set<Element>();
 
-  ClosureTranslator(SsaBuilder builder)
-      : this.builder = builder,
-        this.elements = builder.elements,
-        capturedVariableMapping = new Map<Element, Element>(),
-        closures = <FunctionExpression>[],
-        mutatedVariables = new Set<Element>(),
-        this.closureDataCache = builder.builder.closureDataCache;
-
-  ClosureData translate(Node node) {
-    // Closures have already been analyzed when visiting the surrounding
-    // method/function. This also shortcuts for bailout functions.
-    ClosureData cached = closureDataCache[node];
-    if (cached !== null) return cached;
-
+  void translate(Node node) {
     visit(node);
     // 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();
-
-    return closureDataCache[node];
   }
 
   // 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) {
       // The captured variables that need to be stored in a field of the closure
       // class.
       Set<Element> fieldCaptures = new Set<Element>();
-      ClosureData data = closureDataCache[closure];
+      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];
         assert(updatedElement !== null);
         if (fromElement == updatedElement) {
           assert(freeVariableMapping[fromElement] == updatedElement);
           assert(Elements.isLocal(updatedElement));
@@ skipping 174 matching lines @@
          link = link.tail) {
       Node definition = link.head;
       Element element = elements[definition];
       if (capturedVariableMapping.containsKey(element)) {
         result.add(element);
       };
     }
     scopeData.boxedLoopVariables = result;
   }
 
-  ClosureData globalizeClosure(FunctionExpression node, Element element) {
+  ClosureClassMap globalizeClosure(FunctionExpression node, Element element) {
     SourceString closureName =
         new SourceString(compiler.namer.closureName(element));
     ClassElement globalizedElement = new ClosureClassElement(
         closureName, compiler, element.getCompilationUnit());
     FunctionElement callElement =
         new FunctionElement.from(compiler.namer.CLOSURE_INVOCATION_NAME,
                                  element,
                                  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 ClosureData(element, globalizedElement,
-                           callElement, thisElement);
+    return new ClosureClassMap(element, globalizedElement,
+                               callElement, thisElement);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     Element element = elements[node];
     if (element.kind === ElementKind.PARAMETER) {
       // TODO(ahe): This is a hack. This method should *not* call
       // visitChildren.
       return node.name.accept(this);
     }
     bool isClosure = (closureData !== null);
 
     if (isClosure) closures.add(node);
 
     bool oldInsideClosure = insideClosure;
     FunctionElement oldFunctionElement = currentFunctionElement;
-    ClosureData oldClosureData = closureData;
+    ClosureClassMap oldClosureData = closureData;
 
     insideClosure = isClosure;
     currentFunctionElement = elements[node];
     if (insideClosure) {
       closureData = globalizeClosure(node, element);
     } else {
       Element thisElement = null;
       // TODO(floitsch): we should not need to look for generative constructors.
       // At the moment we store only one ClosureData for both the factory and
       // the body.
       if (element.isInstanceMember() ||
           element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
         // TODO(floitsch): currently all variables are considered to be
         // declared in the GENERATIVE_CONSTRUCTOR. Including the 'this'.
         Element thisEnclosingElement = element;
         if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
           ConstructorBodyElement body = element;
           thisEnclosingElement = body.constructor;
         }
         thisElement = new ThisElement(thisEnclosingElement);
       }
-      closureData = new ClosureData(null, null, null, thisElement);
+      closureData = new ClosureClassMap(null, null, null, thisElement);
     }
 
     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);
       }
 
       // 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);
     });
 
-    closureDataCache[node] = closureData;
+    closureMappingCache[node] = closureData;
 
-    ClosureData savedClosureData = closureData;
+    ClosureClassMap savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
     currentFunctionElement = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
     List<Element> freeVariables =
         savedClosureData.freeVariableMapping.getKeys();
@@ skipping 14 matching lines @@
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     bool oldInTryStatement = inTryStatement;
     inTryStatement = true;
     node.visitChildren(this);
     inTryStatement = oldInTryStatement;
   }
 }