Handle NewExpression in SemanticSendVisitor.

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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 1531 matching lines @@
                                        functionNode,
                                        className,
                                        constructorSelector);
       registry.registerImplicitSuperCall(calledConstructor);
       registry.registerStaticUse(calledConstructor);
     }
   }
 
   void verifyThatConstructorMatchesCall(
       FunctionElement caller,
-      FunctionElement lookedupConstructor,
+      ConstructorElementX lookedupConstructor,
       Selector call,
       bool isImplicitSuperCall,
       Node diagnosticNode,
       String className,
       Selector constructorSelector) {
     if (lookedupConstructor == null
         || !lookedupConstructor.isGenerativeConstructor) {
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
@@ skipping 14 matching lines @@
         visitor.compiler.reportError(
             diagnosticNode, MessageKind.CONST_CALLS_NON_CONST);
       }
     }
   }
 
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
-  FunctionElement resolveInitializers(FunctionElement constructor,
-                                      FunctionExpression functionNode) {
+  ConstructorElement resolveInitializers(ConstructorElementX constructor,
+                                         FunctionExpression functionNode) {
     // Keep track of all "this.param" parameters specified for constructor so
     // that we can ensure that fields are initialized only once.
     FunctionSignature functionParameters = constructor.functionSignature;
     functionParameters.forEachParameter((ParameterElement element) {
       if (element.isInitializingFormal) {
         InitializingFormalElement initializingFormal = element;
         checkForDuplicateInitializers(initializingFormal.fieldElement,
                                       element.initializer);
       }
     });
@@ skipping 24 matching lines @@
         } else if (Initializers.isConstructorRedirect(call)) {
           // Check that there is no body (Language specification 7.5.1).  If the
           // constructor is also const, we already reported an error in
           // [resolveMethodElement].
           if (functionNode.hasBody() && !constructor.isConst) {
             error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
           }
           // Check that there are no other initializers.
           if (!initializers.tail.isEmpty) {
             error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
+          } else {
+            constructor.isRedirectingGenerative = true;
           }
           // Check that there are no field initializing parameters.
           Compiler compiler = visitor.compiler;
           FunctionSignature signature = constructor.functionSignature;
           signature.forEachParameter((ParameterElement parameter) {
             if (parameter.isInitializingFormal) {
               Node node = parameter.node;
               error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
             }
           });
@@ skipping 1502 matching lines @@
     Node expression = node.expression;
     if (expression != null) {
       if (enclosingElement.isGenerativeConstructor) {
         // It is a compile-time error if a return statement of the form
         // `return e;` appears in a generative constructor.  (Dart Language
         // Specification 13.12.)
         compiler.reportError(expression,
                              MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
       } else if (!node.isArrowBody && currentAsyncMarker.isYielding) {
         compiler.reportError(
-            node, 
-            MessageKind.RETURN_IN_GENERATOR, 
+            node,
+            MessageKind.RETURN_IN_GENERATOR,
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
   }
 
   visitYield(Yield node) {
     compiler.streamClass.ensureResolved(compiler);
     compiler.iterableClass.ensureResolved(compiler);
     visit(node.expression);
@@ skipping 1656 matching lines @@
   ConstructorResolver(Compiler compiler, this.resolver,
                       {bool this.inConstContext: false})
       : super(compiler);
 
   ResolutionRegistry get registry => resolver.registry;
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
-  failOrReturnErroneousConstructorElement(
-      Element enclosing, Node diagnosticNode,
-      String targetName, MessageKind kind,
-      Map arguments) {
-    if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
+  ErroneousConstructorElementX failOrReturnErroneousConstructorElement(
+      Spannable diagnosticNode,
+      Element enclosing,
+      String name,
+      MessageKind kind,
+      Map arguments,
+      {bool isError: false,
+       bool missingConstructor: false}) {
+    if (missingConstructor) {
       registry.registerThrowNoSuchMethod();
     } else {
       registry.registerThrowRuntimeError();
     }
-    if (inConstContext) {
+    if (isError || inConstContext) {
       compiler.reportError(diagnosticNode, kind, arguments);
     } else {
       compiler.reportWarning(diagnosticNode, kind, arguments);
     }
     return new ErroneousConstructorElementX(
-        kind, arguments, targetName, enclosing);
+        kind, arguments, name, enclosing);
   }
 
   FunctionElement resolveConstructor(ClassElement cls,
                                      Node diagnosticNode,
                                      String constructorName) {
     cls.ensureResolved(compiler);
     Element result = cls.lookupConstructor(constructorName);
     if (result == null) {
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               cls.name,
               constructorName);
       return failOrReturnErroneousConstructorElement(
-          cls,
           diagnosticNode,
-          fullConstructorName,
+          cls, constructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
-          {'constructorName': fullConstructorName});
+          {'constructorName': fullConstructorName},
+          missingConstructor: true);
     } else if (inConstContext && !result.isConst) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
 
   Element visitNewExpression(NewExpression node) {
     inConstContext = node.isConst;
     Node selector = node.send.selector;
     Element element = visit(selector);
@@ skipping 12 matching lines @@
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (!Elements.isUnresolved(element) && !element.isConstructor) {
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         // The unnamed constructor may not exist, so [e] may become unresolved.
         element = resolveConstructor(cls, diagnosticNode, '');
       } else {
         element = failOrReturnErroneousConstructorElement(
-            element, diagnosticNode, element.name, MessageKind.NOT_A_TYPE,
-            {'node': diagnosticNode});
+            diagnosticNode,
+            element, element.name,
+            MessageKind.NOT_A_TYPE, {'node': diagnosticNode});
       }
     } else if (element.isErroneous && element is! ErroneousElementX) {
+      // Parser error. The error has already been reported.
       element = new ErroneousConstructorElementX(
           MessageKind.NOT_A_TYPE, {'node': diagnosticNode},
           element.name, element);
       registry.registerThrowRuntimeError();
     }
 
     if (type == null) {
       if (Elements.isUnresolved(element)) {
         type = const DynamicType();
       } else {
@@ skipping 26 matching lines @@
     if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(compiler);
       return resolveConstructor(cls, name, name.source);
     } else if (element.isPrefix) {
       PrefixElement prefix = element;
       element = prefix.lookupLocalMember(name.source);
       element = Elements.unwrap(element, compiler, node);
       if (element == null) {
         return failOrReturnErroneousConstructorElement(
-            resolver.enclosingElement, name,
-            name.source,
-            MessageKind.CANNOT_RESOLVE,
-            {'name': name});
+            name,
+            resolver.enclosingElement, name.source,
+            MessageKind.CANNOT_RESOLVE, {'name': name});
       } else if (!element.isClass) {
-        error(node, MessageKind.NOT_A_TYPE, {'node': name});
+        return failOrReturnErroneousConstructorElement(
+            name,
+            resolver.enclosingElement, name.source,
+            MessageKind.NOT_A_TYPE, {'node': name},
+            isError: true);
       }
     } else {
       internalError(node.receiver, 'unexpected element $element');
     }
     return element;
   }
 
   Element visitIdentifier(Identifier node) {
     String name = node.source;
     Element element = resolver.reportLookupErrorIfAny(
         lookupInScope(compiler, node, resolver.scope, name), node, name);
     registry.useElement(node, element);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (element == null) {
       return failOrReturnErroneousConstructorElement(
-          resolver.enclosingElement, node, name,
+          node,
+          resolver.enclosingElement, name,
           MessageKind.CANNOT_RESOLVE,
           {'name': name});
     } else if (element.isErroneous) {
       return element;
     } else if (element.isTypedef) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
-            {'typedefName': name});
-      element = new ErroneousConstructorElementX(
-          MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
-          {'typedefName': name}, name, resolver.enclosingElement);
-      registry.registerThrowRuntimeError();
+      element = failOrReturnErroneousConstructorElement(
+          node,
+          resolver.enclosingElement, name,
+          MessageKind.CANNOT_INSTANTIATE_TYPEDEF, {'typedefName': name},
+          isError: true);
     } else if (element.isTypeVariable) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
-            {'typeVariableName': name});
-      element = new ErroneousConstructorElementX(
+      element = failOrReturnErroneousConstructorElement(
+          node,
+          resolver.enclosingElement, name,
           MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
-          {'typeVariableName': name}, name, resolver.enclosingElement);
-      registry.registerThrowRuntimeError();
+          {'typeVariableName': name},
+          isError: true);
     } else if (!element.isClass && !element.isPrefix) {
-      error(node, MessageKind.NOT_A_TYPE, {'node': name});
-      element = new ErroneousConstructorElementX(
-          MessageKind.NOT_A_TYPE, {'node': name}, name,
-          resolver.enclosingElement);
-      registry.registerThrowRuntimeError();
+      element = failOrReturnErroneousConstructorElement(
+          node,
+          resolver.enclosingElement, name,
+          MessageKind.NOT_A_TYPE, {'node': name},
+          isError: true);
     }
     return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     Node constructorReference = node.constructorReference;
     return finishConstructorReference(visit(constructorReference),
         constructorReference, node);
   }
@@ skipping 62 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }