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.implementation === constructor);
+    ClassElement cls = constructor.enclosingElement;
+    if (!cls.isInterface()) return;
+    Type defaultType = cls.defaultClass;
+    if (defaultType === null) {
+      error(node, MessageKind.NO_DEFAULT_CLASS, [cls.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]);
+    }
+    constructor.implementation =
+      defaultClass.lookupConstructor(constructor.name);
+    if (constructor.implementation === null) {

[ngeoffray, 2012/02/17 09:45:21]

Maybe add a comment here that you're looking for the constructor with the name
of the default class, instead of the interface.

[ahe, 2012/02/17 15:43:11]

Done.

+      String name = constructor.name.toString();
+      name = name.replaceFirst(cls.name.toString(),
+                               defaultClass.name.toString());
+      constructor.implementation =
+        defaultClass.lookupConstructor(new SourceString(name));
 
-    if (tree.initializers != null) {
-      new InitializerResolver(visitor, element).resolveInitializers(tree);
+      if (constructor.implementation === null
+          && new SourceString(name) == defaultClass.name

[ngeoffray, 2012/02/17 09:45:21]

You could share new SourceString(name) with line 119

[ahe, 2012/02/17 15:43:11]

Done.

+          && constructor.functionParameters.parameterCount === 0) {

[ngeoffray, 2012/02/17 09:45:21]

constructor.computeParameters(compiler).parameterCount

[ahe, 2012/02/17 15:43:11]

Done.

+        constructor.implementation = defaultClass.getSynthesizedConstructor();
+      }
     }
-    visitor.visit(tree.body);
+    if (constructor === null) {

[ngeoffray, 2012/02/17 09:45:21]

This case cannot happen.

[ahe, 2012/02/17 15:43:11]

Done.

+      error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
+      return null;
+    }
 
-    // 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);
+    if (constructor.implementation === null) {
+      error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR, [name]);
     }
-    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 711 matching lines @@
     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;
       constructorName = Elements.constructConstructorName(className, name);
     } else {
       constructorName = typeName.asIdentifier().source;
     }
+    handleArguments(node.send);

[ngeoffray, 2012/02/17 09:45:21]

This should still be done at the end, otherwise you'll get errors on the
arguments before errors on the type/

[ahe, 2012/02/17 15:43:11]

Done.

     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);
+    cls.resolve(compiler);
+    if (cls.isInterface() && (cls.defaultClass === null)) {
+      error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
+    }
+    FunctionElement 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]);
+      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;
   }
 
   ClassElement resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     ClassElement cls = visit(node);
     typeRequired = old;
     return cls;
@@ skipping 434 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";
   }
 }