Find diagnostic locations for use in new compiler API.

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 52 matching lines @@
       return node.selector.asIdentifier().source;
     } else {
       return const SourceString('');
     }
   }
 
   FunctionElement lookupConstructor(ClassElement classElement, Send send,
                                     [noConstructor(Element)]) {
     final SourceString constructorName = getConstructorName(send);
     final SourceString className = classElement.name;
-    FunctionElement result = classElement.lookupConstructor(className,
-                                                            constructorName,
-                                                            noConstructor);
-    if (result === null && send.arguments.isEmpty()) {
-      result = classElement.getSynthesizedConstructor();
-    }
-    return result;
+    return classElement.lookupConstructor(className,
+                                          constructorName,
+                                          noConstructor);
   }
 
   FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
     FunctionExpression node = constructor.parseNode(compiler);
     // A synthetic constructor does not have a node.
     if (node === null) return null;
     if (node.initializers === null) return null;
     Link<Node> initializers = node.initializers.nodes;
     if (!initializers.isEmpty() &&
         Initializers.isConstructorRedirect(initializers.head)) {
@@ skipping 83 matching lines @@
       defaultClass.lookupConstructor(constructor.name);
 
     // If that fails, try looking up "MyClass.name".
     if (constructor.defaultImplementation === null) {
       SourceString name =
           new SourceString(constructor.name.slowToString().replaceFirst(
               intrface.name.slowToString(),
               defaultClass.name.slowToString()));
       constructor.defaultImplementation = defaultClass.lookupConstructor(name);
 
-      if (constructor.defaultImplementation === null
-          && name == defaultClass.name
-          && constructor.computeParameters(compiler).parameterCount === 0) {
-        constructor.defaultImplementation =
-            defaultClass.getSynthesizedConstructor();
-      }
-
       if (constructor.defaultImplementation === null) {
         // We failed find a constrcutor named either
         // "MyInterface.name" or "MyClass.name".
         error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR2,
               [constructor.name, name]);
       }
     }
   }
 
   TreeElements resolveVariableElement(Element element) {
@@ skipping 940 matching lines @@
     }
     if (node.defaultClause !== null) {
       element.defaultClass = visit(node.defaultClause.nodes.head);
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
       element.interfaces = element.interfaces.prepend(visit(link.head));
     }
     calculateAllSupertypes(element, new Set<ClassElement>());
+    addDefaultConstructorIfNeeded(element);
     return element.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
   Type visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element === null) {
@@ skipping 74 matching lines @@
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
       seen.remove(classElement);
       classElement.allSupertypes = supertypes;
     } else {
       classElement.allSupertypes = const EmptyLink<Type>();
     }
   }
 
+  /**
+   * Add a synthetic nullary constructor if there are no other
+   * constructors.
+   */
+  void addDefaultConstructorIfNeeded(ClassElement element) {
+    if (element.constructors.length != 0) return;
+    SynthesizedConstructorElement constructor =
+      new SynthesizedConstructorElement(element);
+    element.constructors[element.name] = constructor;
+    Type returnType = compiler.types.voidType;
+    constructor.type = new FunctionType(returnType, const EmptyLink<Type>(),
+                                        constructor);
+    constructor.cachedNode =
+      new FunctionExpression(new Identifier(element.position()),
+                             new NodeList.empty(),
+                             new Block(new NodeList.empty()),
+                             null, null, null, null);
+  }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
@@ skipping 182 matching lines @@
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     Element e = visit(selector);
     if (e !== null && e.kind === ElementKind.CLASS) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       compiler.resolver.toResolve.add(cls);
       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;
-      }
+      e = cls.lookupConstructor(cls.name);
     }
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     // TODO(ahe): Do not ignore type arguments.
     return visit(node.typeName);
   }
 
   visitSend(Send node) {
@@ skipping 101 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";
   }
 }