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;
 
+  FunctionElement implementation;
+
   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,

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

Unsurprisingly, this is too much. Why didn't you keep the previous way of doing
it? There was basically three cases:
- element created by the diet-parser (FunctionElement)
- element created for nested functions (FunctionElement.node)
- element created by the backend (FunctionElement.from).

I don't think you need to change that. Maybe the name FunctionElement.node
should be changed to FunctionElement.nested, to make it clearer?

Also this 'implementation' element, is that just for constructors in interfaces?
I'd prefer another name, like defaultImplementation.

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

As we discussed, I'd like to raise the abstraction level for building elements
and plan to return to this.
Great idea. I have changed the name.

+                                     FunctionExpression this.cachedNode,
+                                     ElementKind kind,
+                                     Modifiers this.modifiers,
+                                     Element enclosing,
+                                     FunctionParameters this.functionParameters)
+    : super(name, kind, enclosing)
+  {
+    implementation = this;
+  }
 
   bool isInstanceMember() {
     return isMember()
            && kind != ElementKind.GENERATIVE_CONSTRUCTOR
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
   FunctionParameters computeParameters(Compiler compiler) {
     if (functionParameters !== null) return functionParameters;
@@ skipping 322 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;
 }