Revert "Revert "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() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
     // invariant for all element types.
     if (!isTopLevel()) {
       String holderName = enclosingElement.name.slowToString();
       return '$kind($holderName#${name.slowToString()})';
     } else {
       return '$kind(${name.slowToString()})';
     }
   }
 
@@ skipping 81 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 267 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();
+  }
+
+  bool get isPatched() => patch !== null;
+
+  /**
+   * Applies a patch function to this function. The patch function's body
+   * is used as replacement when parsing this function's body.
+   * This method must not be called after the function has been parsed,
+   * and it must be called at most once.
+   */
+  void setPatch(FunctionElement patchElement) {
+    // Sanity checks. The caller must check these things before calling.
+    assert(patch === null);
+    assert(cachedNode === null);

[Lasse Reichstein Nielsen, 2012/07/02 08:52:12]

The asserts were inverted :(

+    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) {
+    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;
 
   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()}";
 }