Deserialize ResolvedAsts and ResolutionImpacts only when needed for compilation.

pkg/compiler/lib/src/compile_time_constants.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 dart2js.compile_time_constant_evaluator;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 946 matching lines @@
           node, callStructure, arguments, implementation,
           compileArgument: (node) => concreteArgumentMap[node]);
       concreteArguments = concreteArgumentMap.values.toList();
     } else {
       assert(normalizedArguments != null);
       concreteArguments = normalizedArguments;
     }
     if (constructor.isFromEnvironmentConstructor) {
       return createFromEnvironmentConstant(node, constructedType, constructor,
           callStructure, normalizedArguments, concreteArguments);
+    } else if (compiler.serialization.isDeserialized(constructor)) {
+      ConstructedConstantExpression expression =
+          new ConstructedConstantExpression(type, constructor, callStructure,
+              concreteArguments.map((c) => c.expression).toList());
+      return new AstConstant(
+          context,
+          node,
+          expression,
+          expression.evaluate(
+              new _CompilerEnvironment(compiler), constantSystem));
     } else {
       return makeConstructedConstant(
           compiler,
           handler,
           context,
           node,
           type,
           constructor,
           constructedType,
           implementation,
@@ skipping 104 matching lines @@
       Element context,
       Node node,
       InterfaceType type,
       ConstructorElement constructor,
       InterfaceType constructedType,
       ConstructorElement target,
       CallStructure callStructure,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
     if (target.isRedirectingFactory) {
-      // This happens is case of cyclic redirection.
+      // This happens in case of cyclic redirection.
       assert(invariant(node, compiler.compilationFailed,
           message: "makeConstructedConstant can only be called with the "
               "effective target: $constructor"));
       return new ErroneousAstConstant(context, node);
     }
     assert(invariant(
         node,
         callStructure.signatureApplies(constructor.functionSignature) ||
             compiler.compilationFailed,
         message: "Call structure $callStructure does not apply to constructor "
@@ skipping 53 matching lines @@
   final ConstructorElement constructor;
   final Map<Element, AstConstant> definitions;
   final Map<Element, AstConstant> fieldValues;
   final ResolvedAst resolvedAst;
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] must be an implementation element.
    */
-  ConstructorEvaluator(InterfaceType this.constructedType,
-      FunctionElement constructor, ConstantCompiler handler, Compiler compiler)
+  ConstructorEvaluator(
+      InterfaceType this.constructedType,
+      ConstructorElement constructor,
+      ConstantCompiler handler,
+      Compiler compiler)
       : this.constructor = constructor,
         this.definitions = new Map<Element, AstConstant>(),
         this.fieldValues = new Map<Element, AstConstant>(),
         this.resolvedAst =
             compiler.resolution.computeResolvedAst(constructor.declaration),
         super(handler, null, compiler, isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
   }
 
   @override
+  Element get context => resolvedAst.element;
+
+  @override
   TreeElements get elements => resolvedAst.elements;
 
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       AstConstant constant = definitions[element];
       if (constant == null) {
         reporter.internalError(send, "Local variable without value.");
       }
       return constant;
@@ skipping 39 matching lines @@
         if (compiler.options.enableInitializingFormalAccess) {
           definitions[parameter] = argument;
         }
       } else {
         potentiallyCheckType(parameter, argument);
         definitions[parameter] = argument;
       }
     });
   }
 
-  void evaluateSuperOrRedirectSend(
-      List<AstConstant> compiledArguments, FunctionElement targetConstructor) {
-    ConstructorEvaluator evaluator = new ConstructorEvaluator(
-        constructedType.asInstanceOf(targetConstructor.enclosingClass),
-        targetConstructor,
-        handler,
-        compiler);
-    evaluator.evaluateConstructorFieldValues(compiledArguments);
-    // Copy over the fieldValues from the super/redirect-constructor.
-    // No need to go through [updateFieldValue] because the
-    // assignments have already been checked in checked mode.
-    evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
+  void evaluateSuperOrRedirectSend(List<AstConstant> compiledArguments,
+      CallStructure callStructure, ConstructorElement targetConstructor) {
+    InterfaceType type =
+        constructedType.asInstanceOf(targetConstructor.enclosingClass);
+    if (compiler.serialization.isDeserialized(targetConstructor)) {
+      List<ConstantExpression> arguments =
+          compiledArguments.map((c) => c.expression).toList();
+      ConstructedConstantExpression expression =
+          new ConstructedConstantExpression(
+              type, targetConstructor, callStructure, arguments);
+
+      Map<FieldElement, ConstantExpression> fields =
+          expression.computeInstanceFields();
+      fields.forEach((FieldElement field, ConstantExpression expression) {
+        ConstantValue value = expression.evaluate(
+            new _CompilerEnvironment(compiler), constantSystem);
+        fieldValues[field] = new AstConstant(context, null, expression, value);
+      });
+    } else {
+      ConstructorEvaluator evaluator =
+          new ConstructorEvaluator(type, targetConstructor, handler, compiler);
+      evaluator.evaluateConstructorFieldValues(compiledArguments);
+      // Copy over the fieldValues from the super/redirect-constructor.
+      // No need to go through [updateFieldValue] because the
+      // assignments have already been checked in checked mode.
+      evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
+    }
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
    * the [fieldValues] map.
    */
   void evaluateConstructorInitializers() {
     ResolvedAst resolvedAst = constructor.resolvedAst;
     if (resolvedAst.kind != ResolvedAstKind.PARSED) {
       List<AstConstant> compiledArguments = <AstConstant>[];
 
       Function compileArgument = (element) => definitions[element];
       Function compileConstant = handler.compileConstant;
       FunctionElement target = constructor.definingConstructor.implementation;
       CallStructure.addForwardingElementArgumentsToList(constructor,
           compiledArguments, target, compileArgument, compileConstant);
-      evaluateSuperOrRedirectSend(compiledArguments, target);
+      CallStructure callStructure =
+          new CallStructure.fromSignature(target.functionSignature);
+      evaluateSuperOrRedirectSend(compiledArguments, callStructure, target);
       return;
     }
     FunctionExpression functionNode = resolvedAst.node;
     NodeList initializerList = functionNode.initializers;
 
     bool foundSuperOrRedirect = false;
 
     if (initializerList != null) {
       for (Link<Node> link = initializerList.nodes;
           !link.isEmpty;
           link = link.tail) {
         assert(link.head is Send);
         if (link.head is! SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           FunctionElement target = elements[call];
           if (!target.isMalformed) {
+            CallStructure callStructure =
+                elements.getSelector(call).callStructure;
             List<AstConstant> compiledArguments =
                 evaluateArgumentsToConstructor(
-                    call,
-                    elements.getSelector(call).callStructure,
-                    call.arguments,
-                    target,
+                    call, callStructure, call.arguments, target,
                     compileArgument: evaluateConstant);
-            evaluateSuperOrRedirectSend(compiledArguments, target);
+            evaluateSuperOrRedirectSend(
+                compiledArguments, callStructure, target);
           }
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
           assert(!initArguments.isEmpty && initArguments.tail.isEmpty);
           AstConstant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject) {
         assert(superClass != null);
         assert(superClass.isResolved);
 
         FunctionElement targetConstructor =
             superClass.lookupDefaultConstructor();
         // If we do not find a default constructor, an error was reported
         // already and compilation will fail anyway. So just ignore that case.
         if (targetConstructor != null) {
+          CallStructure callStructure = CallStructure.NO_ARGS;
           List<AstConstant> compiledArguments = evaluateArgumentsToConstructor(
               functionNode,
-              CallStructure.NO_ARGS,
+              callStructure,
               const Link<Node>(),
               targetConstructor);
-          evaluateSuperOrRedirectSend(compiledArguments, targetConstructor);
+          evaluateSuperOrRedirectSend(
+              compiledArguments, callStructure, targetConstructor);
         }
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
    */
@@ skipping 76 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }