Support deserialized compilation of the empty program.

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(element.resolvedAst);
+    closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
+        compiler.backend.frontend.getResolvedAst(element.declaration));
 
     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 108 matching lines @@
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
           builder.reporter.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
-          builder.reporter.internalError(local, "Cannot find value $local.");
+          builder.reporter.internalError(
+              local, "Cannot find value $local in ${directLocals.keys}.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
@@ skipping 899 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);
     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 39 matching lines @@
           isReachable = false;
           return false;
         }
       }
 
       return true;
     }
 
     bool doesNotContainCode() {
       // A function with size 1 does not contain any code.
-      return InlineWeeder.canBeInlined(function, 1, true,
+      return InlineWeeder.canBeInlined(functionResolvedAst, 1, true,
           enableUserAssertions: compiler.options.enableUserAssertions);
     }
 
     bool reductiveHeuristic() {
       // The call is on a path which is executed rarely, so inline only if it
       // does not make the program larger.
       if (isCalledOnce(element)) {
-        return InlineWeeder.canBeInlined(function, -1, false,
+        return InlineWeeder.canBeInlined(functionResolvedAst, -1, false,
             enableUserAssertions: compiler.options.enableUserAssertions);
       }
       // TODO(sra): Measure if inlining would 'reduce' the size.  One desirable
       // case we miss by doing nothing is inlining very simple constructors
       // where all fields are initialized with values from the arguments at this
       // call site.  The code is slightly larger (`new Foo(1)` vs `Foo$(1)`) but
       // that usually means the factory constructor is left unused and not
       // emitted.
       // We at least inline bodies that are empty (and thus have a size of 1).
       return doesNotContainCode();
@@ skipping 17 matching lines @@
       }
 
       // Do not inline code that is rarely executed unless it reduces size.
       if (inExpressionOfThrow || inLazyInitializerExpression) {
         return reductiveHeuristic();
       }
 
       if (cachedCanBeInlined == true) {
         // We may have forced the inlining of some methods. Therefore check
         // if we can inline this method regardless of size.
-        assert(InlineWeeder.canBeInlined(function, -1, false,
+        assert(InlineWeeder.canBeInlined(functionResolvedAst, -1, false,
             allowLoops: true,
             enableUserAssertions: compiler.options.enableUserAssertions));
         return true;
       }
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       bool useMaxInliningNodes = true;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
       }
 
       // If a method is called only once, and all the methods in the
       // inlining stack are called only once as well, we know we will
       // save on output size by inlining this method.
       if (isCalledOnce(element)) {
         useMaxInliningNodes = false;
       }
       bool canInline;
       canInline = InlineWeeder.canBeInlined(
-          function, maxInliningNodes, useMaxInliningNodes,
+          functionResolvedAst, maxInliningNodes, useMaxInliningNodes,
           enableUserAssertions: compiler.options.enableUserAssertions);
       if (canInline) {
         backend.inlineCache.markAsInlinable(element, insideLoop: insideLoop);
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
       if (element.isInstanceMember &&
           !element.isGenerativeConstructorBody &&
           (mask == null || mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
                 isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
-      enterInlinedMethod(function, currentNode, compiledArguments,
+      enterInlinedMethod(function, functionResolvedAst, compiledArguments,
           instanceType: instanceType);
       inlinedFrom(function, () {
         if (!isReachable) {
           emitReturn(graph.addConstantNull(compiler), null);
         } else {
           doInline(function);
         }
       });
       leaveInlinedMethod();
     }
@@ skipping 126 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
-    ast.FunctionExpression function = functionElement.node;
+    ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (backend.isJsInterop(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
           value, sourceInformationBuilder.buildReturn(functionElement.node)));
@@ skipping 133 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);
+    assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, instanceType);
-    localsHandler.closureData = compiler.closureToClassMapper
-        .computeClosureToClassMapping(function.resolvedAst);
+    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;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
     ClassElement enclosing = function.enclosingClass;
     if ((function.isConstructor || function.isGenerativeConstructorBody) &&
         backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = compiledArguments[argumentIndex++];
         localsHandler.updateLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable), argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
-    resolvedAst = function.resolvedAst;
-    assert(resolvedAst != null);
     returnType = signature.type.returnType;
     stack = <HInstruction>[];
 
     insertTraceCall(function);
     insertCoverageCall(function);
   }
 
   void restoreState(AstInliningState state) {
     localsHandler = state.oldLocalsHandler;
     returnLocal = state.oldReturnLocal;
@@ skipping 123 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 = callee.resolvedAst;
+      resolvedAst = backend.frontend.getResolvedAst(callee);
       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, constructors, fieldValues);
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
@@ skipping 146 matching lines @@
         ast.Expression initializer = member.initializer;
         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;
           ResolvedAst savedResolvedAst = resolvedAst;
-          resolvedAst = member.resolvedAst;
+          resolvedAst = backend.frontend.getResolvedAst(member);
           // In case the field initializer uses closures, run the
           // closure to class mapper.
           compiler.closureToClassMapper
               .computeClosureToClassMapping(resolvedAst);
           inlinedFrom(member, () => right.accept(this));
           resolvedAst = savedResolvedAst;
           fieldValues[member] = pop();
         }
       });
     });
@@ skipping 186 matching lines @@
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant =
               new InterceptorConstantValue(classElement.thisType);
           interceptor = graph.addConstant(constant, compiler);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
-      ResolvedAst resolvedAst = constructor.resolvedAst;
+      ResolvedAst resolvedAst = backend.frontend.getResolvedAst(constructor);
       ast.Node node = resolvedAst.node;
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
 
       FunctionSignature functionSignature = body.functionSignature;
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
@@ skipping 5476 matching lines @@
   }
 
   visitTypeVariable(ast.TypeVariable node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
-  void enterInlinedMethod(FunctionElement function, ast.Node _,
-      List<HInstruction> compiledArguments,
+  void enterInlinedMethod(FunctionElement function,
+      ResolvedAst functionResolvedAst, List<HInstruction> compiledArguments,
       {InterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
         function,
         returnLocal,
         returnType,
         resolvedAst,
         stack,
         localsHandler,
         inTryStatement,
         allInlinedFunctionsCalledOnce && isFunctionCalledOnce(function));
+    resolvedAst = functionResolvedAst;
     inliningStack.add(state);
 
     // Setting up the state of the (AST) builder is performed even when the
     // inlined function is in IR, because the irInliner uses the [returnElement]
     // of the AST builder.
     setupStateForInlining(function, compiledArguments,
         instanceType: instanceType);
   }
 
   void leaveInlinedMethod() {
@@ skipping 176 matching lines @@
   int nodeCount = 0;
   final int maxInliningNodes;
   final bool useMaxInliningNodes;
   final bool allowLoops;
   final bool enableUserAssertions;
 
   InlineWeeder(this.maxInliningNodes, this.useMaxInliningNodes, this.allowLoops,
       this.enableUserAssertions);
 
   static bool canBeInlined(
-      FunctionElement function, int maxInliningNodes, bool useMaxInliningNodes,
+      ResolvedAst resolvedAst, int maxInliningNodes, bool useMaxInliningNodes,
       {bool allowLoops: false, bool enableUserAssertions: null}) {
     assert(enableUserAssertions is bool); // Ensure we passed it.
-    if (function.resolvedAst.elements.containsTryStatement) return false;
+    if (resolvedAst.elements.containsTryStatement) return false;
 
     InlineWeeder weeder = new InlineWeeder(maxInliningNodes,
         useMaxInliningNodes, allowLoops, enableUserAssertions);
-    ast.FunctionExpression functionExpression = function.node;
+    ast.FunctionExpression functionExpression = resolvedAst.node;
     weeder.visit(functionExpression.initializers);
     weeder.visit(functionExpression.body);
     weeder.visit(functionExpression.asyncModifier);
     return !weeder.tooDifficult;
   }
 
   bool registerNode() {
     if (!useMaxInliningNodes) return true;
     if (nodeCount++ > maxInliningNodes) {
       tooDifficult = true;
@@ skipping 461 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;
 }