First step towards having patch files for generic libraries.

lib/compiler/implementation/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 186 matching lines @@
 
   Element getOutermostEnclosingMemberOrTopLevel() {
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isMember() || e.isTopLevel()) {
         return e;
       }
     }
     return null;
   }
 
-  toString() {
+  String toString() {

[Johnni Winther, 2012/06/29 09:34:43]

Thank you!

     if (!isTopLevel()) {
       String holderName = enclosingElement.name.slowToString();
       return '$kind($holderName#${name.slowToString()})';
     } else {
       return '$kind(${name.slowToString()})';
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
@@ skipping 79 matching lines @@
 class LibraryElement extends CompilationUnitElement {
   // TODO(ahe): Library element should not be a subclass of
   // CompilationUnitElement.
 
   Link<CompilationUnitElement> compilationUnits =
     const EmptyLink<CompilationUnitElement>();
   Link<ScriptTag> tags = const EmptyLink<ScriptTag>();
   ScriptTag libraryTag;
   Map<SourceString, Element> elements;
   bool canUseNative = false;
+  LibraryElement patch = null;
 
   LibraryElement(Script script)
       : elements = new Map<SourceString, Element>(),
         super.library(script);
 
+  bool get isPatched() => patch !== null;
+
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(ScriptTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     topLevelElements = topLevelElements.prepend(element);
@@ skipping 252 matching lines @@
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
 
   FunctionSignature functionSignature;
 
   /**
+   * A function declaration that should be parsed instead of the current one.
+   * The patch should be parsed as if it was in the current scope. Its
+   * signature must match this function's signature.
+   */
+  // TODO(lrn): Consider using [defaultImplementation] to store the patch.
+  FunctionElement patch = null;
+
+  /**
    * 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 modifiers,
                   Element enclosing)
-    : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
+      : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
                        ElementKind kind,
                        Modifiers modifiers,
                        Element enclosing)
-    : this.tooMuchOverloading(name, node, kind, modifiers, enclosing, null);
+      : this.tooMuchOverloading(name, node, kind, modifiers, enclosing, null);
 
   FunctionElement.from(SourceString name,
                        FunctionElement other,
                        Element enclosing)
-    : this.tooMuchOverloading(name, other.cachedNode, other.kind,
-                              other.modifiers, enclosing,
-                              other.functionSignature);
+      : this.tooMuchOverloading(name, other.cachedNode, other.kind,
+                                other.modifiers, enclosing,
+                                other.functionSignature);
 
   FunctionElement.tooMuchOverloading(SourceString name,
                                      FunctionExpression this.cachedNode,
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
-    : super(name, kind, enclosing)
-  {
+      : super(name, kind, enclosing) {
     defaultImplementation = this;
   }
 
+  CompilationUnitElement getCompilationUnit() {
+    if (patch !== null) return patch.getCompilationUnit();
+    return super.getCompilationUnit();
+  }
+
+  void setPatch(FunctionElement patchElement) {
+    if (cachedNode !== null) throw "Patch After Parsing";

[Johnni Winther, 2012/06/29 09:34:43]

Is that the appropriate way to signal internal errors? What about the reportX
functions in Compiler?

[Lasse Reichstein Nielsen, 2012/06/29 12:01:35]

It isn't really. The problem is that the element doesn't know the compiler, so
it can't report the error. This is just fallback error in case the caller hasn't
checked it already, which it should. And it doesn't, so I'll make it.

+    this.patch = patchElement;
+    cachedNode = patchElement.cachedNode;
+  }
+
   bool isInstanceMember() {
     return isMember()
            && kind != ElementKind.GENERATIVE_CONSTRUCTOR
            && !modifiers.isFactory()
            && !modifiers.isStatic();
   }
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignature !== null) return functionSignature;
     compiler.withCurrentElement(this, () {
@@ skipping 13 matching lines @@
   int parameterCount(Compiler compiler) {
     return computeSignature(compiler).parameterCount;
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     type = compiler.computeFunctionType(this, computeSignature(compiler));
     return type;
   }
 
-  Node parseNode(DiagnosticListener listener) => cachedNode;
+  Node parseNode(DiagnosticListener listener) {

[Johnni Winther, 2012/06/29 09:34:43]

This is also overridden in ConstructorBodyElement (besides
PartialFunctionElement which you handle).

[Lasse Reichstein Nielsen, 2012/06/29 12:01:35]

True. I don't try to handle constructors yet (or anything inside classes at all,
or getters anywhere), but I'll make sure to remember it.

+    if (cachedNode !== null) return cachedNode;
+    if (patch !== null) {
+      cachedNode = patch.parseNode(listener);
+    }
+    return cachedNode;
+  }
 
   Token position() => cachedNode.getBeginToken();
 
   FunctionElement asFunctionElement() => this;
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
@@ skipping 49 matching lines @@
   Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
   LinkedHashMap<SourceString, TypeVariableElement> typeParameters;
   bool isResolved = false;
   bool isBeingResolved = false;
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
 
   Link<Type> allSupertypes;
+  ClassElement patch = null;

[Johnni Winther, 2012/06/29 09:34:43]

This is currently unused, right?

[Lasse Reichstein Nielsen, 2012/06/29 12:01:35]

Yes. At some point there will be a patch class element here, and when we
parseNode the class, we will also apply the patch. That way it will still be
lazily parsed, both this class and the patch class. 

 
   ClassElement(SourceString name, CompilationUnitElement enclosing, this.id)
     : localMembers = new Map<SourceString, Element>(),
       constructors = new Map<SourceString, Element>(),
       typeParameters = new LinkedHashMap<SourceString, TypeVariableElement>(),
       super(name, ElementKind.CLASS, enclosing);
 
   void addMember(Element element, DiagnosticListener listener) {
     members = members.prepend(element);
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
@@ skipping 340 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }