Compute NewStructure in resolution.

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';
+import '../resolution/tree_elements.dart' show
+    TreeElements;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show
     CallStructure;
 import '../universe/selector.dart' show
     Selector;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 
@@ skipping 2614 matching lines @@
   final ConstructorAccessSemantics semantics;
   final Selector selector;
 
   NewInvokeStructure(this.semantics, this.selector);
 
   CallStructure get callStructure => selector.callStructure;
 
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     switch (semantics.kind) {
       case ConstructorAccessKind.GENERATIVE:
+        ConstructorElement constructor = semantics.element;
+        if (constructor.isRedirectingGenerative) {
+          return visitor.visitRedirectingGenerativeConstructorInvoke(
+              node, constructor, semantics.type,
+              node.send.argumentsNode, callStructure, arg);
+        }
         return visitor.visitGenerativeConstructorInvoke(
-            node, semantics.element, semantics.type,
-            node.send.argumentsNode, callStructure, arg);
-      case ConstructorAccessKind.REDIRECTING_GENERATIVE:
-        return visitor.visitRedirectingGenerativeConstructorInvoke(
-            node, semantics.element, semantics.type,
+            node, constructor, semantics.type,
             node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.FACTORY:
-        return visitor.visitFactoryConstructorInvoke(
-            node, semantics.element, semantics.type,
-            node.send.argumentsNode, callStructure, arg);
-      case ConstructorAccessKind.REDIRECTING_FACTORY:
-        return visitor.visitRedirectingFactoryConstructorInvoke(
-            node, semantics.element, semantics.type,
-            semantics.effectiveTargetSemantics.element,
-            semantics.effectiveTargetSemantics.type,
+        ConstructorElement constructor = semantics.element;
+        if (constructor.isRedirectingFactory) {
+          if (constructor.isEffectiveTargetMalformed) {
+            return visitor.visitUnresolvedRedirectingFactoryConstructorInvoke(
+                node, semantics.element, semantics.type,
+                node.send.argumentsNode, callStructure, arg);
+          }
+          ConstructorElement effectiveTarget = constructor.effectiveTarget;
+          InterfaceType effectiveTargetType =
+              constructor.computeEffectiveTargetType(semantics.type);
+          if (callStructure.signatureApplies(
+                  effectiveTarget.functionSignature)) {
+            return visitor.visitRedirectingFactoryConstructorInvoke(
+                node, semantics.element, semantics.type,
+                effectiveTarget, effectiveTargetType,
+                node.send.argumentsNode, callStructure, arg);
+          } else {
+            return visitor.visitUnresolvedRedirectingFactoryConstructorInvoke(
+                            node, semantics.element, semantics.type,
+                            node.send.argumentsNode, callStructure, arg);
+          }
+        }
+        if (callStructure.signatureApplies(constructor.functionSignature)) {
+          return visitor.visitFactoryConstructorInvoke(
+              node, constructor, semantics.type,
+              node.send.argumentsNode, callStructure, arg);
+        }
+        return visitor.visitConstructorIncompatibleInvoke(
+            node, constructor, semantics.type,
             node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.ABSTRACT:
         return visitor.visitAbstractClassConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.UNRESOLVED_CONSTRUCTOR:
         return visitor.visitUnresolvedConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, selector, arg);
       case ConstructorAccessKind.UNRESOLVED_TYPE:
         return visitor.visitUnresolvedClassConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, selector, arg);
       case ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR:
         return visitor.errorNonConstantConstructorInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, callStructure, arg);
-      case ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY:
-        return visitor.visitUnresolvedRedirectingFactoryConstructorInvoke(
-            node, semantics.element, semantics.type,
-            node.send.argumentsNode, callStructure, arg);
       case ConstructorAccessKind.INCOMPATIBLE:
         return visitor.visitConstructorIncompatibleInvoke(
             node, semantics.element, semantics.type,
             node.send.argumentsNode, callStructure, arg);
     }
     throw new SpannableAssertionFailure(node,
         "Unhandled constructor invocation kind: ${semantics.kind}");
   }
 
   String toString() => 'new($semantics,$selector)';
@@ skipping 24 matching lines @@
       case ConstantInvokeKind.INT_FROM_ENVIRONMENT:
         return visitor.visitIntFromEnvironmentConstructorInvoke(
             node, constant, arg);
       case ConstantInvokeKind.STRING_FROM_ENVIRONMENT:
         return visitor.visitStringFromEnvironmentConstructorInvoke(
             node, constant, arg);
     }
   }
 }
 
+/// 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);
+
+  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())`.
+      return visitor.errorNonConstantConstructorInvoke(
+          node, element, type,
+          node.send.argumentsNode, selector.callStructure, arg);
+    } else {
+      ConstantInvokeKind kind;
+      switch (constant.kind) {
+        case ConstantExpressionKind.CONSTRUCTED:
+          return visitor.visitConstConstructorInvoke(node, constant, arg);
+        case ConstantExpressionKind.BOOL_FROM_ENVIRONMENT:
+          return visitor.visitBoolFromEnvironmentConstructorInvoke(
+              node, constant, arg);
+        case ConstantExpressionKind.INT_FROM_ENVIRONMENT:
+          return visitor.visitIntFromEnvironmentConstructorInvoke(
+              node, constant, arg);
+        case ConstantExpressionKind.STRING_FROM_ENVIRONMENT:
+          return visitor.visitStringFromEnvironmentConstructorInvoke(
+              node, constant, arg);
+        default:
+          throw new SpannableAssertionFailure(
+              node, "Unexpected constant kind $kind: ${constant.getText()}");
+      }
+    }
+  }
+}
+
 /// The structure of a parameter declaration.
 abstract class ParameterStructure<R, A> {
   final VariableDefinitions definitions;
   final Node node;
   final ParameterElement parameter;
 
   ParameterStructure(this.definitions, this.node, this.parameter);
 
   /// Calls the matching visit method on [visitor] with [definitions] and [arg].
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg);
@@ skipping 213 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;
 }