Replace LateConstInvokeStructure after analysis.

pkg/compiler/lib/src/resolution/members.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.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
@@ skipping 3826 matching lines @@
     if (!isInvalid) {
       // [constructor] might be the implementation element
       // and only declaration elements may be registered.
       registry.registerStaticUse(new StaticUse.constructorInvoke(
           constructor.declaration, callStructure));
       // TODO(johniwinther): Avoid registration of `type` in face of redirecting
       // factory constructors.
       registry.registerTypeUse(new TypeUse.instantiation(type));
     }
 
+    ResolutionResult resolutionResult = const NoneResult();
     if (node.isConst) {
       bool isValidAsConstant = !isInvalid && constructor.isConst;
 
       if (constructor == compiler.symbolConstructor) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant = compiler.resolver.constantCompiler
             .compileNode(argumentNode, registry.mapping);
         ConstantValue name = compiler.constants.getConstantValue(constant);
         if (!name.isString) {
           DartType type = name.getType(coreTypes);
@@ skipping 16 matching lines @@
         reporter.reportErrorMessage(
             node.send.selector, MessageKind.TYPE_VARIABLE_IN_CONSTANT);
         isValidAsConstant = false;
         isInvalid = true;
       }
 
       if (result.isDeferred) {
         isValidAsConstant = false;
       }
 
+      // Callback hook for when the compile-time constant evaluator has
+      // analyzed the constant.
+      // TODO(johnniwinther): Remove this when all constants are computed
+      // in resolution.
+      Function onAnalyzed;
       if (isValidAsConstant &&
           argumentsResult.isValidAsConstant &&
           // TODO(johnniwinther): Remove this when all constants are computed
           // in resolution.
           !constructor.isFromEnvironmentConstructor) {
         CallStructure callStructure = argumentsResult.callStructure;
         List<ConstantExpression> arguments = argumentsResult.constantArguments;
 
         ConstructedConstantExpression constant =
             new ConstructedConstantExpression(
                 type, constructor, callStructure, arguments);
         registry.registerNewStructure(node,
             new ConstInvokeStructure(ConstantInvokeKind.CONSTRUCTED, constant));
-        return new ConstantResult(node, constant);
+        resolutionResult = new ConstantResult(node, constant);
       } else if (isInvalid) {
         // Known to be non-constant.
         kind == ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR;
         registry.registerNewStructure(
             node,
             new NewInvokeStructure(
                 new ConstructorAccessSemantics(kind, constructor, type),
                 selector));
       } else {
         // Might be valid but we don't know for sure. The compile-time constant
         // evaluator will compute the actual constant as a deferred action.
-        registry.registerNewStructure(
-            node, new LateConstInvokeStructure(registry.mapping));
+        LateConstInvokeStructure structure =
+            new LateConstInvokeStructure(registry.mapping);
+        // TODO(johnniwinther): Avoid registering the
+        // [LateConstInvokeStructure]; it might not be necessary.
+        registry.registerNewStructure(node, structure);
+        onAnalyzed = () {
+          registry.registerNewStructure(node, structure.resolve(node));
+        };
       }
+
+      analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
       if (constructor == compiler.symbolConstructor &&
           !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
         reporter.reportHintMessage(node.newToken, MessageKind.NON_CONST_BLOAT,
             {'name': coreClasses.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
     }
 
-    return const NoneResult();
+    return resolutionResult;
   }
 
   void checkConstMapKeysDontOverrideEquals(
       Spannable spannable, MapConstantValue map) {
     for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
       ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == coreClasses.stringClass) continue;
@@ skipping 13 matching lines @@
       assert(invariant(node, compiler.compilationFailed));
       return;
     }
 
     ConstantValue value = compiler.constants.getConstantValue(constant);
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
   }
 
-  void analyzeConstantDeferred(Node node, {bool enforceConst: true}) {
+  void analyzeConstantDeferred(Node node,
+      {bool enforceConst: true, void onAnalyzed()}) {
     addDeferredAction(enclosingElement, () {
       analyzeConstant(node, enforceConst: enforceConst);
+      if (onAnalyzed != null) {
+        onAnalyzed();
+      }
     });
   }
 
   bool validateSymbol(Node node, String name, {bool reportError: true}) {
     if (name.isEmpty) return true;
     if (name.startsWith('_')) {
       if (reportError) {
         reporter.reportErrorMessage(
             node, MessageKind.PRIVATE_IDENTIFIER, {'value': name});
       }
@@ skipping 687 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }