Revert "Make ClosureTask only accept Element-level APIs instead of resolvedAst."

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';
@@ skipping 24 matching lines @@
   Compiler compiler;
   ClosureTask(Compiler compiler)
       : compiler = compiler,
         super(compiler.measurer);
 
   String get name => "Closure Simplifier";
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   ClosureClassMap getMemberMap(MemberElement member) {
-    return getClosureToClassMapping(member);
+    return getClosureToClassMapping(member.resolvedAst);
   }
 
   ClosureClassMap getLocalFunctionMap(LocalFunctionElement localFunction) {
-    return getClosureToClassMapping(localFunction);
+    return getClosureToClassMapping(localFunction.resolvedAst);
   }
 
   /// Returns the [ClosureClassMap] computed for [resolvedAst].
-  ClosureClassMap getClosureToClassMapping(Element element) {
+  ClosureClassMap getClosureToClassMapping(ResolvedAst resolvedAst) {
     return measure(() {
+      Element element = resolvedAst.element;
       if (element.isGenerativeConstructorBody) {
         ConstructorBodyElement constructorBody = element;
         element = constructorBody.constructor;
       }
       ClosureClassMap closureClassMap = _closureMappingCache[element];
-      assert(closureClassMap != null,
-          failedAt(element, "No ClosureClassMap computed for ${element}."));
+      assert(
+          closureClassMap != null,
+          failedAt(resolvedAst.element,
+              "No ClosureClassMap computed for ${element}."));
       return closureClassMap;
     });
   }
 
   /// Create [ClosureClassMap]s for all live members.
   void createClosureClasses(ClosedWorldRefiner closedWorldRefiner) {
     compiler.enqueuer.resolution.processedEntities
         .forEach((MemberElement 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(element, closedWorldRefiner);
+      computeClosureToClassMapping(resolvedAst, closedWorldRefiner);
     });
   }
 
   ClosureClassMap computeClosureToClassMapping(
-      Element element, ClosedWorldRefiner closedWorldRefiner) {
+      ResolvedAst resolvedAst, ClosedWorldRefiner closedWorldRefiner) {
     return measure(() {
+      Element element = resolvedAst.element;
       ClosureClassMap cached = _closureMappingCache[element];
       if (cached != null) return cached;
-      if (element.resolvedAst.kind != ResolvedAstKind.PARSED) {
+      if (resolvedAst.kind != ResolvedAstKind.PARSED) {
         return _closureMappingCache[element] =
             new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
       return reporter.withCurrentElement(element.implementation, () {
-        Node node = element.resolvedAst.node;
-        TreeElements elements = element.resolvedAst.elements;
+        Node node = resolvedAst.node;
+        TreeElements elements = resolvedAst.elements;
 
         ClosureTranslator translator = new ClosureTranslator(
             compiler, closedWorldRefiner, 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");
           _closureMappingCache[element] =
               new ClosureClassMap(null, null, null, new ThisLocal(element));
         } else {
           assert(element.isField,
               failedAt(element, "Expected $element to be a field."));
-          Node initializer = element.resolvedAst.body;
+          Node initializer = resolvedAst.body;
           if (initializer != null) {
             // The lazy initializer of a static.
             translator.translateLazyInitializer(element, node, initializer);
           } else {
             assert(
                 element.isInstanceMember,
                 failedAt(
                     element,
                     "Expected $element (${element.runtimeType}) "
                     "to be an instance field."));
@@ skipping 1007 matching lines @@
       ThisLocal thisElement = null;
       if (element.isInstanceMember || element.isGenerativeConstructor) {
         thisElement = new ThisLocal(element);
       }
       closureData = new ClosureClassMap(null, null, null, thisElement);
       if (element is MethodElement) {
         needsRti = compiler.options.enableTypeAssertions ||
             compiler.backend.rtiNeed.methodNeedsRti(element);
       }
     }
-    closureMappingCache[element] = closureData;
     closureMappingCache[element.declaration] = closureData;
     if (closureData.callElement != null) {
       closureMappingCache[closureData.callElement] = closureData;
     }
 
     inNewScope(node, () {
       // If the method needs RTI, or checked mode is set, we need to
       // escape the potential type variables used in that closure.
       if (needsRti) {
         analyzeTypeVariables(element.type);
@@ skipping 89 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;
 }