Store ResolvedAst on AstElement

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 309 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(AstElement element, ast.Node node) {
     assert(invariant(element, element.isImplementation));
     Compiler compiler = builder.compiler;
-    closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
-        compiler.backend.frontend.getResolvedAst(element.declaration));
+    closureData = compiler.closureToClassMapper
+        .computeClosureToClassMapping(element.resolvedAst);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
       ClosureScope scopeData = closureData.capturingScopes[node];
       params.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
@@ skipping 1034 matching lines @@
       // We only inline factory JavaScript interop constructors.
       return false;
     }
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
 
     if (compiler.elementHasCompileTimeError(element)) return false;
 
     FunctionElement function = element;
-    ResolvedAst functionResolvedAst = backend.frontend.getResolvedAst(function);
+    ResolvedAst functionResolvedAst = function.resolvedAst;
     bool insideLoop = loopNesting > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (compiler.options.disableInlining) return false;
@@ skipping 443 matching lines @@
    * The arguments of the function are inserted into the [localsHandler].
    *
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       FunctionElement function, List<HInstruction> compiledArguments,
       {InterfaceType instanceType}) {
-    ResolvedAst resolvedAst =
-        compiler.backend.frontend.getResolvedAst(function.declaration);
+    ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, instanceType);
     localsHandler.closureData =
         compiler.closureToClassMapper.computeClosureToClassMapping(resolvedAst);
     returnLocal = new SyntheticLocal("result", function);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(compiler));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
@@ skipping 155 matching lines @@
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       ResolvedAst oldResolvedAst = resolvedAst;
-      resolvedAst = backend.frontend.getResolvedAst(callee);
+      resolvedAst = callee.resolvedAst;
       ClosureClassMap oldClosureData = localsHandler.closureData;
       ClosureClassMap newClosureData = compiler.closureToClassMapper
           .computeClosureToClassMapping(resolvedAst);
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(resolvedAst.node, callee);
       }
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
@@ skipping 20 matching lines @@
       ConstructorElement constructor,
       List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
     assert(invariant(constructor, constructor.isSynthesized,
         message: "Unexpected unsynthesized constructor: $constructor"));
     List<HInstruction> arguments = <HInstruction>[];
     HInstruction compileArgument(ParameterElement parameter) {
       return localsHandler.readLocal(parameter);
     }
 
-    Element target = constructor.definingConstructor.implementation;
+    ConstructorElement target = constructor.definingConstructor.implementation;
     bool match = !target.isMalformed &&
         CallStructure.addForwardingElementArgumentsToList(
             constructor,
             arguments,
             target,
             compileArgument,
             handleConstantForOptionalParameter);
     if (!match) {
       if (compiler.elementHasCompileTimeError(constructor)) {
         return;
       }
       // If this fails, the selector we constructed for the call to a
       // forwarding constructor in a mixin application did not match the
       // constructor (which, for example, may happen when the libraries are
       // not compatible for private names, see issue 20394).
       reporter.internalError(
           constructor, 'forwarding constructor call does not match');
     }
-    inlineSuperOrRedirect(backend.frontend.getResolvedAst(target), arguments,
+    inlineSuperOrRedirect(target.resolvedAst, arguments,
         constructorResolvedAsts, fieldValues, constructor);
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
@@ skipping 26 matching lines @@
               ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
           CallStructure callStructure =
               elements.getSelector(call).callStructure;
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
           inlinedFrom(resolvedAst, () {
             compiledArguments =
                 makeStaticArgumentList(callStructure, arguments, target);
           });
-          inlineSuperOrRedirect(
-              backend.frontend.getResolvedAst(target.declaration),
-              compiledArguments,
-              constructorResolvedAsts,
-              fieldValues,
-              constructor);
+          inlineSuperOrRedirect(target.resolvedAst, compiledArguments,
+              constructorResolvedAsts, fieldValues, constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(resolvedAst, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
@@ skipping 12 matching lines @@
         FunctionElement target = superClass.lookupDefaultConstructor();
         if (target == null) {
           reporter.internalError(
               superClass, "No default constructor available.");
         }
         List<HInstruction> arguments = CallStructure.NO_ARGS.makeArgumentsList(
             const Link<ast.Node>(),
             target.implementation,
             null,
             handleConstantForOptionalParameter);
-        inlineSuperOrRedirect(
-            backend.frontend.getResolvedAst(target.declaration),
-            arguments,
-            constructorResolvedAsts,
-            fieldValues,
-            constructor);
+        inlineSuperOrRedirect(target.resolvedAst, arguments,
+            constructorResolvedAsts, fieldValues, constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(
       ClassElement classElement, Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       if (compiler.elementHasCompileTimeError(member)) return;
       reporter.withCurrentElement(member, () {
-        ResolvedAst fieldResolvedAst = backend.frontend.getResolvedAst(member);
+        ResolvedAst fieldResolvedAst = member.resolvedAst;
         ast.Node node = fieldResolvedAst.node;
         ast.Expression initializer = fieldResolvedAst.body;
         if (initializer == null) {
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
           if (!backend.isNativeOrExtendsNative(classElement)) {
             fieldValues[member] = graph.addConstantNull(compiler);
           }
         } else {
           ast.Node right = initializer;
@@ skipping 6400 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }