Resolve constructors with type arguments.

dart/frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 937 matching lines @@
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     if (node.isConst()) {
       warning(node, MessageKind.GENERIC,
               ['const expressions are not implemented']);
     }
     Node selector = node.send.selector;
-    if (selector.asTypeAnnotation() === null) {
-      cancel(
-          node, 'named constructors with type arguments are not implemented');
-    }
 
     FunctionElement constructor = resolveConstructor(node);
     handleArguments(node.send);
     if (constructor === null) return null;
     // TODO(karlklose): handle optional arguments.
     if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     useElement(node.send, constructor);
     return null;
   }
 
   FunctionElement resolveConstructor(NewExpression node) {
-    SourceString constructorName;
-    Node selector = node.send.selector;
-    Node typeName = selector.asTypeAnnotation().typeName;
-    if (typeName.asSend() !== null) {
-      SourceString className = typeName.asSend().receiver.asIdentifier().source;
-      SourceString name = typeName.asSend().selector.asIdentifier().source;
-      constructorName = Elements.constructConstructorName(className, name);
-    } else {
-      constructorName = typeName.asIdentifier().source;
+    FunctionElement constructor =
+      node.accept(new ConstructorResolver(compiler, this));
+    if (constructor === null) {
+      error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
     }
-    ClassElement cls = resolveTypeRequired(selector);
-    if (cls === null) {
-      error(selector, MessageKind.CANNOT_RESOLVE_TYPE, [selector]);
-      return null;
-    }
-    cls.resolve(compiler);
-    if (cls.isInterface() && (cls.defaultClass === null)) {
-      error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
-    }
-    FunctionElement constructor = cls.lookupConstructor(constructorName);
-    if (constructor !== null) return constructor;
-    if (constructorName == cls.name && node.send.argumentsNode.isEmpty()) {
-      return cls.getSynthesizedConstructor();
-    }
-    error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
-    return null;
+    return constructor;
   }
 
   ClassElement resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     ClassElement cls = visit(node);
     typeRequired = old;
     return cls;
   }
 
@@ skipping 404 matching lines @@
     node.accept(new ResolverVisitor(compiler, enclosingElement));
   }
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
       ? enclosingElement.enclosingElement : null;
   }
 }
 
+class ConstructorResolver extends CommonResolverVisitor<Element> {
+  final ResolverVisitor resolver;
+  ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
+
+  visitNode(Node node) {
+    throw 'not supported';
+  }
+
+  visitNewExpression(NewExpression node) {
+    Node selector = node.send.selector;
+    Element e = visit(selector);
+    if (e !== null && e.kind === ElementKind.CLASS) {
+      ClassElement cls = e;
+      cls.resolve(compiler);
+      compiler.resolver.toResolve.add(cls);

[ngeoffray, 2012/03/07 11:32:06]

You don't need to add it to the list of classes to resolve if you already
resolved it. 

[ahe, 2012/03/07 11:34:32]

I think I do for its supertypes.

[ngeoffray, 2012/03/07 11:37:41]

I see. Initially, toResolve was only for delaying resolution of type
annotations. Why isn't the element.resolve method making sure the supertypes are
computed?

[ahe, 2012/03/07 21:04:09]

OK. This is somewhat complicated. I have implemented it, but I think it should
be its own CL.

+      if (cls.isInterface() && (cls.defaultClass === null)) {
+        error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
+      }
+      FunctionElement constructor = cls.lookupConstructor(cls.name);
+      if (constructor === null && node.send.argumentsNode.isEmpty()) {
+        e = cls.getSynthesizedConstructor();
+      } else {
+        e = constructor;
+      }
+    }
+    return e;
+  }
+
+  visitTypeAnnotation(TypeAnnotation node) {
+    // TODO(ahe): Do not ignore type arguments.
+    return visit(node.typeName);
+  }
+
+  visitSend(Send node) {
+    Element e = visit(node.receiver);
+    if (e === null) return null; // TODO(ahe): Return erroneous element.
+
+    if (e.kind === ElementKind.CLASS) {
+      ClassElement cls = e;
+      cls.resolve(compiler);
+      compiler.resolver.toResolve.add(cls);

[ngeoffray, 2012/03/07 11:32:06]

ditto

+      if (cls.isInterface() && (cls.defaultClass === null)) {
+        error(node.receiver, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
+              [cls.name]);
+      }
+      Identifier name = node.selector.asIdentifier();
+      if (name === null) {
+        internalError(node.selector, 'unexpected node');
+      }
+      SourceString constructorName =
+        Elements.constructConstructorName(cls.name, name.source);
+      FunctionElement constructor = cls.lookupConstructor(constructorName);
+      if (constructor === null) {
+        error(name, MessageKind.CANNOT_FIND_CONSTRUCTOR, [name]);
+      }
+      e = constructor;
+    } else {
+      internalError(node.resolve, 'unexpected element $e');
+    }
+    return e;
+  }
+
+  Element visitIdentifier(Identifier node) {
+    SourceString name = node.source;
+    Element e = resolver.lookup(node, name);
+    if (e === null) {
+      error(node, MessageKind.CANNOT_RESOLVE, [name]);
+      // TODO(ahe): Return erroneous element.
+    } else if (e.kind !== ElementKind.CLASS) {
+      error(node, MessageKind.NOT_A_TYPE, [name]);
+    }
+    return e;
+  }
+}
+
 class Scope {
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
   abstract Element lookup(SourceString name);
 }
 
 class MethodScope extends Scope {
@@ skipping 41 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }