Unify parsing of constructor references.

dart/lib/compiler/implementation/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 {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1908 matching lines @@
         includeSuperMembers: true);
     return null;
   }
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
-    // Resolve the constructor that [node] refers to.
-    ConstructorResolver visitor =
-        new ConstructorResolver(compiler, this, node.isConst());
-    FunctionElement constructor = node.accept(visitor);
-    // Try to resolve the type that the new-expression constructs.
-    TypeAnnotation annotation = node.send.getTypeAnnotation();
-    if (Elements.isUnresolved(constructor)) {
-      // Resolve the type arguments. We cannot create a type and check the
-      // number of type arguments for this annotation, because we do not know
-      // the element.
-      Link arguments = const Link<Node>();
-      if (annotation.typeArguments != null) {
-        arguments = annotation.typeArguments.nodes;
-      }
-      for (Node argument in arguments) {
-        resolveTypeRequired(argument);
-      }
-    } else {
-      // Resolve and store the type this annotation resolves to. The type
-      // is used in the backend, e.g., for creating runtime type information.
-      // TODO(karlklose): This will resolve the class element again. Refactor
-      // so we can use the TypeResolver.
-      resolveTypeRequired(annotation);
-    }
-    return constructor;
+    return node.accept(new ConstructorResolver(compiler, this));
   }
 
   DartType resolveTypeRequired(TypeAnnotation node) {
     bool old = typeRequired;
     typeRequired = true;
     DartType result = resolveTypeAnnotation(node);
     typeRequired = old;
     return result;
   }
 
@@ skipping 917 matching lines @@
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
-  // TODO(ngeoffray): have this context at the call site.
-  final bool inConstContext;
+  bool inConstContext = false;
+  DartType type;
 
-  ConstructorResolver(Compiler compiler,
-                      this.resolver,
-                      this.inConstContext)
-      : super(compiler);
+  ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                SourceString targetName, MessageKind kind,
                                List arguments) {
     if (inConstContext) {
       error(diagnosticNode, kind, arguments);
@@ skipping 32 matching lines @@
           new SourceString(fullConstructorName),
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           [fullConstructorName]);
     } else if (inConstContext && !result.modifiers.isConst()) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
 
   visitNewExpression(NewExpression node) {
+    inConstContext = node.isConst();
     Node selector = node.send.selector;
     Element e = visit(selector);
     if (!Elements.isUnresolved(e) && identical(e.kind, ElementKind.CLASS)) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass == null)) {
         error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
       }
       e = lookupConstructor(cls, selector, const SourceString(''));
     }
+    if (type == null) {
+      if (Elements.isUnresolved(e)) {
+        type = compiler.dynamicClass.computeType(compiler);
+      } else {
+        type = e.getEnclosingClass().computeType(compiler).asRaw();
+      }
+    }
+    resolver.mapping.setType(node, type);
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
-    return visit(node.typeName);
+    assert(invariant(node, type == null));
+    type = resolver.resolveTypeRequired(node);
+    return resolver.mapping[node];
   }
 
   visitSend(Send node) {
     Element e = visit(node.receiver);
     if (Elements.isUnresolved(e)) return e;
     Identifier name = node.selector.asIdentifier();
     if (name == null) internalError(node.selector, 'unexpected node');
 
     if (identical(e.kind, ElementKind.CLASS)) {
       ClassElement cls = e;
@@ skipping 31 matching lines @@
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }