Replace LateConstInvokeStructure after analysis.

pkg/compiler/lib/src/resolution/send_structure.dart

 // Copyright (c) 2015, 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.send_structure;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
@@ skipping 2082 matching lines @@
 
 /// A constant constructor invocation that couldn't be determined fully during
 /// resolution.
 // TODO(johnniwinther): Remove this when all constants are computed during
 // resolution.
 class LateConstInvokeStructure<R, A> extends NewStructure<R, A> {
   final TreeElements elements;
 
   LateConstInvokeStructure(this.elements);
 
+  /// Convert this new structure into a regular new structure using the data
+  /// available in [elements].
+  NewStructure resolve(NewExpression node) {
+    Element element = elements[node.send];
+    Selector selector = elements.getSelector(node.send);
+    DartType type = elements.getType(node);
+    ConstantExpression constant = elements.getConstant(node);
+    if (element.isMalformed ||
+        constant == null ||
+        constant.kind == ConstantExpressionKind.ERRONEOUS) {
+      // This is a non-constant constant constructor invocation, like
+      // `const Const(method())`.
+      return new NewInvokeStructure(
+          new ConstructorAccessSemantics(
+              ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, element, type),
+          selector);
+    } else {
+      ConstantInvokeKind kind;
+      switch (constant.kind) {
+        case ConstantExpressionKind.CONSTRUCTED:
+          kind = ConstantInvokeKind.CONSTRUCTED;
+          break;
+        case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
+          kind = ConstantInvokeKind.BOOL_FROM_ENVIRONMENT;
+          break;
+        case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
+          kind = ConstantInvokeKind.INT_FROM_ENVIRONMENT;
+          break;
+        case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
+          kind = ConstantInvokeKind.STRING_FROM_ENVIRONMENT;
+          break;
+        default:
+          throw new SpannableAssertionFailure(
+              node, "Unexpected constant kind $kind: ${constant.getText()}");
+      }
+      return new ConstInvokeStructure(kind, constant);
+    }
+  }
+
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
     DartType type = elements.getType(node);
     ConstantExpression constant = elements.getConstant(node);
     if (element.isMalformed ||
         constant == null ||
         constant.kind == ConstantExpressionKind.ERRONEOUS) {
       // This is a non-constant constant constructor invocation, like
       // `const Const(method())`.
@@ skipping 228 matching lines @@
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }