Use shared implementation of Stopwatch.

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 40 matching lines @@
           return resolveVariableElement(element);
 
         default:
           compiler.unimplemented(
               "resolver", node: element.parseNode(compiler));
       }
     });
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
-    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR &&
-        constructorElements[element] !== null) {
-      return constructorElements[element];
+    return compiler.withCurrentElement(element, () {
+      bool isConstructor = element.kind === ElementKind.GENERATIVE_CONSTRUCTOR;
+      if (isConstructor) {
+        TreeElements elements = constructorElements[element];
+        if (elements !== null) return elements;
+      }
+      FunctionExpression tree = element.parseNode(compiler);
+      if (isConstructor) {
+        resolveConstructorImplementation(element, tree);
+      }
+      ResolverVisitor visitor = new ResolverVisitor(compiler, element);
+      visitor.useElement(tree, element);
+      visitor.setupFunction(tree, element);
+
+      if (tree.initializers != null) {
+        new InitializerResolver(visitor, element).resolveInitializers(tree);
+      }
+      visitor.visit(tree.body);
+
+      // Resolve the type annotations encountered in the method.
+      Link<ClassElement> newResolvedClasses = const EmptyLink<ClassElement>();
+      while (!toResolve.isEmpty()) {
+        ClassElement classElement = toResolve.removeFirst();
+        if (!classElement.isResolved) {
+          classElement.resolve(compiler);
+        }
+        newResolvedClasses = newResolvedClasses.prepend(classElement);
+      }
+      checkClassHierarchy(newResolvedClasses);
+      if (isConstructor) {
+        constructorElements[element] = visitor.mapping;
+      }
+      return visitor.mapping;
+    });
+  }
+
+  void resolveConstructorImplementation(FunctionElement constructor,
+                                        FunctionExpression node) {
+    assert(constructor.defaultImplementation === constructor);
+    ClassElement intrface = constructor.enclosingElement;
+    if (!intrface.isInterface()) return;
+    Type defaultType = intrface.defaultClass;
+    if (defaultType === null) {
+      error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
     }
-    FunctionExpression tree = element.parseNode(compiler);
-    ResolverVisitor visitor = new ResolverVisitor(compiler, element);
-    visitor.useElement(tree, element);
-    visitor.setupFunction(tree, element);
+    ClassElement defaultClass = defaultType.element;
+    defaultClass.resolve(compiler);
+    if (defaultClass.isInterface()) {
+      error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
+            [defaultClass.name]);
+    }
+    // We have now established the following:
+    // [intrface] is an interface, let's say "MyInterface".
+    // [defaultClass] is a class, let's say "MyClass".
 
-    if (tree.initializers != null) {
-      new InitializerResolver(visitor, element).resolveInitializers(tree);
+    // First look up the constructor named "MyInterface.name".
+    constructor.defaultImplementation =
+      defaultClass.lookupConstructor(constructor.name);
+
+    // If that fails, try looking up "MyClass.name".
+    if (constructor.defaultImplementation === null) {
+      SourceString name =
+          new SourceString(constructor.name.toString().replaceFirst(
+              intrface.name.toString(),
+              defaultClass.name.toString()));
+      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]);
+      }
     }
-    visitor.visit(tree.body);
-
-    // Resolve the type annotations encountered in the method.
-    Link<ClassElement> newResolvedClasses = const EmptyLink<ClassElement>();
-    while (!toResolve.isEmpty()) {
-      ClassElement classElement = toResolve.removeFirst();
-      if (!classElement.isResolved) {
-        classElement.resolve(compiler);
-      }
-      newResolvedClasses = newResolvedClasses.prepend(classElement);
-    }
-    checkClassHierarchy(newResolvedClasses);
-    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
-      constructorElements[element] = visitor.mapping;
-    }
-    return visitor.mapping;
   }
 
   TreeElements resolveVariableElement(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
     if (tree is SendSet) {
       SendSet send = tree;
       visitor.visit(send.arguments.head);
     }
     return visitor.mapping;
@@ skipping 700 matching lines @@
   }
 
   visitNewExpression(NewExpression node) {
     if (node.isConst()) cancel(node, '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) {
-      Identifier receiver = typeName.asSend().receiver.asIdentifier();
-      Identifier selector = typeName.asSend().selector.asIdentifier();
-      SourceString className = receiver.source;
-      SourceString name = selector.source;
+      SourceString className = typeName.asSend().receiver.asIdentifier().source;
+      SourceString name = typeName.asSend().selector.asIdentifier().source;
       constructorName = Elements.constructConstructorName(className, name);
     } else {
       constructorName = typeName.asIdentifier().source;
     }
     ClassElement cls = resolveTypeRequired(selector);
-    Element constructor = null;
-    if (cls !== null) {
-      cls.resolve(compiler);
-      if (cls.isInterface() && (cls.defaultClass === null)) {
-        error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
-      }
-      constructor = cls.lookupConstructor(constructorName);
-      if (constructorName == cls.name
-          && constructor === null
-          && node.send.argumentsNode.isEmpty()) {
-        constructor = cls.getSynthesizedConstructor();
-      }
-      if (constructor === null) {
-        error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
-      } else {
-        FunctionElement function = constructor;
-        // TODO(karlklose): handle optional arguments.
-        if (node.send.argumentCount() != function.parameterCount(compiler)) {
-          // TODO(ngeoffray): reslution error with wrong number of
-          // parameters. We cannot do this rigth now because of the
-          // List constructor.
-        }
-      }
-    } else {
+    if (cls === null) {
       error(selector, MessageKind.CANNOT_RESOLVE_TYPE, [selector]);
+      return null;
     }
-    handleArguments(node.send);
-    useElement(node.send, constructor);
+    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;
   }
 
   ClassElement resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     ClassElement cls = visit(node);
     typeRequired = old;
     return cls;
   }
@@ skipping 433 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";
   }
 }