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
@@ skipping 3995 matching lines @@
       // [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) {
@@ skipping 20 matching lines @@
             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);
+        registry.registerNewStructure(node, structure);

[Siggi Cherem (dart-lang), 2016/04/08 16:10:45]

do we need to register it if we are replacing it later?

[Johnni Winther, 2016/04/11 07:40:45]

I'm not sure. Adding a TODO for trying in a follow CL:

+        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 16 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()}) {

[Siggi Cherem (dart-lang), 2016/04/08 16:10:45]

... eventually we should consider using futures in cases like these where we are
just waiting for the async work to be done.

[Johnni Winther, 2016/04/11 07:40:45]

Acknowledged.

     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 727 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);
 }