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

pkg/compiler/lib/src/closure.dart

Index: pkg/compiler/lib/src/closure.dart
diff --git a/pkg/compiler/lib/src/closure.dart b/pkg/compiler/lib/src/closure.dart
index c459c1cb1c37260be577e38202e82e261933426d..de78463f8c6d3099db29d11acb0159be5bfedc22 100644
--- a/pkg/compiler/lib/src/closure.dart
+++ b/pkg/compiler/lib/src/closure.dart
@@ -41,26 +41,23 @@ class ClosureTask extends CompilerTask implements ClosureClassMaps {
   DiagnosticReporter get reporter => compiler.reporter;
 
   ClosureClassMap getMemberMap(MemberElement member) {
-    return getClosureToClassMapping(member.resolvedAst);
+    return getClosureToClassMapping(member);
   }
 
   ClosureClassMap getLocalFunctionMap(LocalFunctionElement localFunction) {
-    return getClosureToClassMapping(localFunction.resolvedAst);
+    return getClosureToClassMapping(localFunction);
   }
 
   /// Returns the [ClosureClassMap] computed for [resolvedAst].
-  ClosureClassMap getClosureToClassMapping(ResolvedAst resolvedAst) {
+  ClosureClassMap getClosureToClassMapping(Element element) {
     return measure(() {

[Johnni Winther, 2017/06/02 16:39:27]

I suspect that you need to add `element = element.declaration` here (that's
implicit in `resolvedAst.element`)

[Emily Fortuna, 2017/06/05 17:33:59]

hm. I ran all the tests and they passed without this. 

-      Element element = resolvedAst.element;
       if (element.isGenerativeConstructorBody) {
         ConstructorBodyElement constructorBody = element;
         element = constructorBody.constructor;
       }
       ClosureClassMap closureClassMap = _closureMappingCache[element];
-      assert(
-          closureClassMap != null,
-          failedAt(resolvedAst.element,
-              "No ClosureClassMap computed for ${element}."));
+      assert(closureClassMap != null,
+          failedAt(element, "No ClosureClassMap computed for ${element}."));
       return closureClassMap;
     });
   }
@@ -77,23 +74,22 @@ class ClosureTask extends CompilerTask implements ClosureClassMaps {
         // Skip top-level/static fields without an initializer.
         return;
       }
-      computeClosureToClassMapping(resolvedAst, closedWorldRefiner);
+      computeClosureToClassMapping(element, closedWorldRefiner);
     });
   }
 
   ClosureClassMap computeClosureToClassMapping(
-      ResolvedAst resolvedAst, ClosedWorldRefiner closedWorldRefiner) {
+      Element element, ClosedWorldRefiner closedWorldRefiner) {
     return measure(() {
-      Element element = resolvedAst.element;
       ClosureClassMap cached = _closureMappingCache[element];
       if (cached != null) return cached;
-      if (resolvedAst.kind != ResolvedAstKind.PARSED) {
+      if (element.resolvedAst.kind != ResolvedAstKind.PARSED) {
         return _closureMappingCache[element] =
             new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
       return reporter.withCurrentElement(element.implementation, () {
-        Node node = resolvedAst.node;
-        TreeElements elements = resolvedAst.elements;
+        Node node = element.resolvedAst.node;
+        TreeElements elements = element.resolvedAst.elements;
 
         ClosureTranslator translator = new ClosureTranslator(
             compiler, closedWorldRefiner, elements, _closureMappingCache);
@@ -110,7 +106,7 @@ class ClosureTask extends CompilerTask implements ClosureClassMaps {
         } else {
           assert(element.isField,
               failedAt(element, "Expected $element to be a field."));
-          Node initializer = resolvedAst.body;
+          Node initializer = element.resolvedAst.body;
           if (initializer != null) {
             // The lazy initializer of a static.
             translator.translateLazyInitializer(element, node, initializer);
@@ -1138,6 +1134,7 @@ class ClosureTranslator extends Visitor {
             compiler.backend.rtiNeed.methodNeedsRti(element);
       }
     }
+    closureMappingCache[element] = closureData;
     closureMappingCache[element.declaration] = closureData;
     if (closureData.callElement != null) {
       closureMappingCache[closureData.callElement] = closureData;