Use shared implementation of Stopwatch.

dart/frog/leg/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 349 matching lines @@
   int get parameterCount() => requiredParameterCount + optionalParameterCount;
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
 
   FunctionParameters functionParameters;
 
+  /**
+   * If this is an interface constructor, [defaultImplementation] will
+   * changed by the resolver to point to the default
+   * implementation. Otherwise, [:defaultImplementation === this:].
+   */
+  FunctionElement defaultImplementation;
+
   FunctionElement(SourceString name,
                   ElementKind kind,
-                  Modifiers this.modifiers,
+                  Modifiers modifiers,
                   Element enclosing)
-    : super(name, kind, enclosing);
+    : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
                        ElementKind kind,
-                       Modifiers this.modifiers,
+                       Modifiers modifiers,
                        Element enclosing)
-    : super(name, kind, enclosing), cachedNode = node;
+    : this.tooMuchOverloading(name, node, kind, modifiers, enclosing, null);
 
   FunctionElement.from(SourceString name,
                        FunctionElement other,
                        Element enclosing)
-    : super(name, other.kind, enclosing),
-      cachedNode = other.cachedNode,
-      modifiers = other.modifiers,
-      functionParameters = other.functionParameters;
+    : this.tooMuchOverloading(name, other.cachedNode, other.kind,
+                              other.modifiers, enclosing,
+                              other.functionParameters);
+
+  FunctionElement.tooMuchOverloading(SourceString name,
+                                     FunctionExpression this.cachedNode,
+                                     ElementKind kind,
+                                     Modifiers this.modifiers,
+                                     Element enclosing,
+                                     FunctionParameters this.functionParameters)
+    : super(name, kind, enclosing)
+  {
+    defaultImplementation = this;
+  }
 
   bool isInstanceMember() {
     return isMember()
            && kind != ElementKind.GENERATIVE_CONSTRUCTOR
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
   FunctionParameters computeParameters(Compiler compiler) {
     if (functionParameters !== null) return functionParameters;
@@ skipping 191 matching lines @@
     Element result = constructors[normalizedName];
     if (result === null && noMatch !== null) {
       result = noMatch(lookupLocalMember(constructorName));
     }
     return result;
   }
 
   bool canHaveDefaultConstructor() => constructors.length == 0;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
+    // TODO(ahe): Get rid of this method. Add the
+    // SynthesizedConstructorElement to [constructors] if empty when
+    // [resolve] is called.
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
     }
     return synthesizedConstructor;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
@@ skipping 111 matching lines @@
   bool isContinueTarget = false;
 
   StatementElement(this.origin, Element enclosingElement)
       : super(const SourceString(""), ElementKind.STATEMENT, enclosingElement);
   StatementElement.label(String name, this.origin, Element enclosingElement)
       : super(new SourceString(name), ElementKind.STATEMENT, enclosingElement);
   bool get isTarget() => isBreakTarget || isContinueTarget;
 
   Node parseNode(DiagnosticListener l) => origin;
 }