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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
   bool isParameterChecked(Element element);
 }
@@ skipping 1887 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 890 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;

[Johnni Winther, 2012/10/22 09:41:38]

Document the semantics and usage of [isConstContext] and [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) {

[Johnni Winther, 2012/10/22 09:30:31]

Document where [type] has been set.

+      type = e.getEnclosingClass().computeType(compiler);

[Johnni Winther, 2012/10/22 09:41:38]

I don't think this is the right type. For 'new Object()' the type is right, but
for 'new List()' the type should not be 'List<E>' but and [InterfaceType] with
no type arguments based on the 'List' element, i.e. the type 'List'.

+    }
+    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 263 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }