Compute NewStructure in resolution.

pkg/compiler/lib/src/resolution/send_resolver.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.semantics_visitor.resolver;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../tree/tree.dart';
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
 
-import 'access_semantics.dart';
 import 'semantic_visitor.dart';
 import 'send_structure.dart';
 import 'tree_elements.dart';
 
-abstract class SendResolverMixin {
-  TreeElements get elements;
-
-  internalError(Spannable spannable, String message);
-
-  ConstructorAccessSemantics computeConstructorAccessSemantics(
-        ConstructorElement constructor,
-        CallStructure callStructure,
-        DartType type,
-        {bool mustBeConstant: false}) {
-    if (mustBeConstant && !constructor.isConst) {
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, constructor, type);
-    }
-    if (constructor.isMalformed) {
-      if (constructor is ErroneousElement) {
-        ErroneousElement error = constructor;
-        if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR ||
-            error.messageKind == MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR) {
-          return new ConstructorAccessSemantics(
-              ConstructorAccessKind.UNRESOLVED_CONSTRUCTOR, constructor, type);
-        }
-      }
-      return new ConstructorAccessSemantics(
-          ConstructorAccessKind.UNRESOLVED_TYPE, constructor, type);
-    } else if (constructor.isRedirectingFactory) {
-      ConstructorElement effectiveTarget = constructor.effectiveTarget;
-      if (effectiveTarget == constructor ||
-          effectiveTarget.isMalformed ||
-          (mustBeConstant && !effectiveTarget.isConst)) {
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
-            constructor,
-            type);
-      }
-      ConstructorAccessSemantics effectiveTargetSemantics =
-          computeConstructorAccessSemantics(
-              effectiveTarget,
-              callStructure,
-              constructor.computeEffectiveTargetType(type));
-      if (effectiveTargetSemantics.isErroneous) {
-        return new RedirectingFactoryConstructorAccessSemantics(
-            ConstructorAccessKind.ERRONEOUS_REDIRECTING_FACTORY,
-            constructor,
-            type,
-            effectiveTargetSemantics);
-      }
-      return new RedirectingFactoryConstructorAccessSemantics(
-          ConstructorAccessKind.REDIRECTING_FACTORY,
-          constructor,
-          type,
-          effectiveTargetSemantics);
-    } else {
-      if (!callStructure.signatureApplies(constructor.functionSignature)) {
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.INCOMPATIBLE,
-            constructor,
-            type);
-      } else if (constructor.isFactoryConstructor) {
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.FACTORY, constructor, type);
-      } else if (constructor.isRedirectingGenerative) {
-        if (constructor.enclosingClass.isAbstract) {
-            return new ConstructorAccessSemantics(
-                ConstructorAccessKind.ABSTRACT, constructor, type);
-        }
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.REDIRECTING_GENERATIVE, constructor, type);
-      } else if (constructor.enclosingClass.isAbstract) {
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.ABSTRACT, constructor, type);
-      } else {
-        return new ConstructorAccessSemantics(
-            ConstructorAccessKind.GENERATIVE, constructor, type);
-      }
-    }
-  }
-
-  NewStructure computeNewStructure(NewExpression node) {
-    Element element = elements[node.send];
-    Selector selector = elements.getSelector(node.send);
-    DartType type = elements.getType(node);
-
-    ConstructorAccessSemantics constructorAccessSemantics =
-        computeConstructorAccessSemantics(
-            element, selector.callStructure, type,
-            mustBeConstant: node.isConst);
-    if (node.isConst) {
-      ConstantExpression constant = elements.getConstant(node);
-      if (constructorAccessSemantics.isErroneous ||
-          constant == null ||
-          constant.kind == ConstantExpressionKind.ERRONEOUS) {
-        // This is a non-constant constant constructor invocation, like
-        // `const Const(method())`.
-        constructorAccessSemantics = new ConstructorAccessSemantics(
-            ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, element, type);
-      } 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:
-            return internalError(
-                node, "Unexpected constant kind $kind: ${constant.getText()}");
-        }
-        return new ConstInvokeStructure(kind, constant);
-      }
-    }
-    return new NewInvokeStructure(constructorAccessSemantics, selector);
-  }
-}
-
 abstract class DeclStructure<R, A> {
   final FunctionElement element;
 
   DeclStructure(this.element);
 
   /// Calls the matching visit method on [visitor] with [node] and [arg].
   R dispatch(SemanticDeclarationVisitor<R, A> visitor,
              FunctionExpression node,
              A arg);
 }
@@ skipping 315 matching lines @@
       return internalError(node, "Unexpected variable $element.");
     }
     if (element.isConst) {
       ConstantExpression constant = elements.getConstant(element.initializer);
       return new ConstantVariableStructure(kind, node, element, constant);
     } else {
       return new NonConstantVariableStructure(kind, node, element);
     }
   }
 }