Use shared implementation of Stopwatch.

dart/frog/leg/elements/elements.dart

Index: dart/frog/leg/elements/elements.dart
diff --git a/dart/frog/leg/elements/elements.dart b/dart/frog/leg/elements/elements.dart
index bc34765653118d4866ba7cf7bcedbbb4e27b9b61..e9ade31b193fdc7cb1efb8559293b6afdcdaff4f 100644
--- a/dart/frog/leg/elements/elements.dart
+++ b/dart/frog/leg/elements/elements.dart
@@ -367,26 +367,38 @@ class FunctionElement extends Element {
 
   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()