Eagerly compute closure classes

pkg/compiler/lib/src/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 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/expressions.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
 import 'elements/modelx.dart'
     show BaseFunctionElementX, ClassElementX, ElementX;
 import 'elements/visitor.dart' show ElementVisitor;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'resolution/tree_elements.dart' show TreeElements;
 import 'tokens/token.dart' show Token;
 import 'tree/tree.dart';
 import 'universe/world_builder.dart' show CodegenWorldBuilder;
 import 'util/util.dart';
 
 class ClosureTask extends CompilerTask {
-  Map<Node, ClosureClassMap> closureMappingCache;
+  Map<Element, ClosureClassMap> _closureMappingCache =
+      <Element, ClosureClassMap>{};
   Compiler compiler;
   ClosureTask(Compiler compiler)
-      : closureMappingCache = new Map<Node, ClosureClassMap>(),
-        compiler = compiler,
+      : compiler = compiler,
         super(compiler.measurer);
 
   String get name => "Closure Simplifier";
 
   DiagnosticReporter get reporter => compiler.reporter;
 
+  /// Returns the [ClosureClassMap] computed for [resolvedAst].
+  ClosureClassMap getClosureToClassMapping(ResolvedAst resolvedAst) {
+    return measure(() {
+      Element element = resolvedAst.element;
+      if (element.isGenerativeConstructorBody) {
+        ConstructorBodyElement constructorBody = element;
+        element = constructorBody.constructor;
+      }
+      ClosureClassMap closureClassMap = _closureMappingCache[element];
+      assert(invariant(resolvedAst.element, closureClassMap != null,
+          message: "No ClosureClassMap computed for ${element}."));
+      return closureClassMap;
+    });
+  }
+
+  /// Create [ClosureClassMap]s for all live members.
+  void createClosureClasses() {
+    compiler.enqueuer.resolution.processedElements
+        .forEach((AstElement element) {
+      ResolvedAst resolvedAst = element.resolvedAst;
+      if (element.isAbstract) return;
+      if (element.isField &&
+          !element.isInstanceMember &&
+          resolvedAst.body == null) {
+        // Skip top-level/static fields without an initializer.
+        return;
+      }
+      computeClosureToClassMapping(resolvedAst);
+    });
+  }
+
   ClosureClassMap computeClosureToClassMapping(ResolvedAst resolvedAst) {
     return measure(() {
       Element element = resolvedAst.element;
+      ClosureClassMap cached = _closureMappingCache[element];
+      if (cached != null) return cached;
       if (resolvedAst.kind != ResolvedAstKind.PARSED) {
-        return new ClosureClassMap(null, null, null, new ThisLocal(element));
+        return _closureMappingCache[element] =
+            new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
       return reporter.withCurrentElement(element.implementation, () {
         Node node = resolvedAst.node;
         TreeElements elements = resolvedAst.elements;
 
-        ClosureClassMap cached = closureMappingCache[node];
-        if (cached != null) return cached;
-
         ClosureTranslator translator =
-            new ClosureTranslator(compiler, elements, closureMappingCache);
+            new ClosureTranslator(compiler, elements, _closureMappingCache);
 
         // The translator will store the computed closure-mappings inside the
         // cache. One for given node and one for each nested closure.
         if (node is FunctionExpression) {
           translator.translateFunction(element, node);
         } else if (element.isSynthesized) {
           reporter.internalError(
               element, "Unexpected synthesized element: $element");
-          return new ClosureClassMap(null, null, null, new ThisLocal(element));
+          _closureMappingCache[element] =
+              new ClosureClassMap(null, null, null, new ThisLocal(element));
         } else {
           assert(invariant(element, element.isField,
               message: "Expected $element to be a field."));
           Node initializer = resolvedAst.body;
           if (initializer != null) {
             // The lazy initializer of a static.
             translator.translateLazyInitializer(element, node, initializer);
           } else {
             assert(invariant(element, element.isInstanceMember,
                 message: "Expected $element (${element
                     .runtimeType}) to be an instance field."));
-            closureMappingCache[node] =
+            _closureMappingCache[element] =
                 new ClosureClassMap(null, null, null, new ThisLocal(element));
           }
         }
-        assert(closureMappingCache[node] != null);
-        return closureMappingCache[node];
+        assert(invariant(element, _closureMappingCache[element] != null,
+            message: "No ClosureClassMap computed for ${element}."));
+        return _closureMappingCache[element];
       });
     });
   }
 
-  ClosureClassMap getMappingForNestedFunction(FunctionExpression node) {
-    return measure(() {
-      ClosureClassMap nestedClosureData = closureMappingCache[node];
-      if (nestedClosureData == null) {
-        reporter.internalError(node, "No closure cache.");
-      }
-      return nestedClosureData;
-    });
-  }
-
   void forgetElement(var closure) {
     ClosureClassElement cls;
     if (closure is ClosureFieldElement) {
       cls = closure.closureClass;
     } else if (closure is SynthesizedCallMethodElementX) {
       cls = closure.closureClass;
     } else {
       throw new SpannableAssertionFailure(
           closure, 'Not a closure: $closure (${closure.runtimeType}).');
     }
@@ skipping 417 matching lines @@
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
   final TreeElements elements;
   int closureFieldCounter = 0;
   int boxedFieldCounter = 0;
   bool inTryStatement = false;
 
-  final Map<Node, ClosureClassMap> closureMappingCache;
+  final Map<Element, ClosureClassMap> closureMappingCache;
 
   // Map of captured variables. Initially they will map to `null`. If
   // a variable needs to be boxed then the scope declaring the variable
   // will update this to mapping to the capturing [BoxFieldElement].
   Map<Local, BoxFieldElement> _capturedVariableMapping =
       new Map<Local, BoxFieldElement>();
 
   // List of encountered closures.
-  List<Expression> closures = <Expression>[];
+  List<LocalFunctionElement> closures = <LocalFunctionElement>[];
 
   // The local variables that have been declared in the current scope.
   List<LocalVariableElement> scopeVariables;
 
   // Keep track of the mutated local variables so that we don't need to box
   // non-mutated variables.
   Set<LocalVariableElement> mutatedVariables = new Set<LocalVariableElement>();
 
   MemberElement outermostElement;
   ExecutableElement executableContext;
@@ skipping 74 matching lines @@
     visitInvokable(element, node, () {
       visit(initializer);
     });
     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.
   void updateClosures() {
-    for (Expression closure in closures) {
+    for (LocalFunctionElement closure in closures) {
       // The captured variables that need to be stored in a field of the closure
       // class.
       Set<Local> fieldCaptures = new Set<Local>();
       Set<BoxLocal> boxes = new Set<BoxLocal>();
       ClosureClassMap data = closureMappingCache[closure];
       // We get a copy of the keys and iterate over it, to avoid modifications
       // to the map while iterating over it.
       Iterable<Local> freeVariables = data.freeVariables.toList();
       freeVariables.forEach((Local fromElement) {
         assert(data.isFreeVariable(fromElement));
@@ skipping 423 matching lines @@
       ExecutableElement element, Node node, void visitChildren()) {
     bool oldInsideClosure = insideClosure;
     Element oldFunctionElement = executableContext;
     ClosureClassMap oldClosureData = closureData;
 
     insideClosure = outermostElement != null;
     LocalFunctionElement closure;
     executableContext = element;
     if (insideClosure) {
       closure = element;
-      closures.add(node);
+      closures.add(closure);
       closureData = globalizeClosure(node, closure);
     } else {
       outermostElement = element;
       ThisLocal thisElement = null;
       if (element.isInstanceMember || element.isGenerativeConstructor) {
         thisElement = new ThisLocal(element);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
     }
-    closureMappingCache[node] = closureData;
+    closureMappingCache[element.declaration] = closureData;
+    if (closureData.callElement != null) {
+      closureMappingCache[closureData.callElement] = closureData;
+    }
 
     inNewScope(node, () {
       DartType type = element.type;
       // If the method needs RTI, or checked mode is set, we need to
       // escape the potential type variables used in that closure.
       if (element is FunctionElement &&
           (compiler.backend.methodNeedsRti(element) ||
               compiler.options.enableTypeAssertions)) {
         analyzeTypeVariables(type);
       }
@@ skipping 85 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }