Patch refactoring.

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('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 96 matching lines @@
   toString() => id;
 }
 
 class Element implements Spannable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
   Element(this.name, this.kind, this.enclosingElement) {
-    assert(getLibrary() !== null);
+    assert(isErroneous() || getImplementationLibrary() !== null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(DiagnosticListener listener) {
-    listener.cancel("Internal Error: $this.parseNode", token: position());
+    listener.internalErrorOnElement(this, 'not implemented');
   }
 
   DartType computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement === null);
     annotation.annotatedElement = this;
     metadata = metadata.prepend(annotation);
@@ skipping 48 matching lines @@
 
   /**
    * Is [:true:] if this element is a patch.
    *
    * If [:true:] this element has a non-null [origin] field.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   bool get isPatch => false;
 
-
   /**
    * Is [:true:] if this element defines the implementation for the entity of
    * this element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
-  bool get isImplementation => implementation === this;
+  bool get isImplementation => !isPatched;
 
   /**
    * Is [:true:] if this element introduces the entity of this element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
-  bool get isDeclaration => declaration === this;
+  bool get isDeclaration => !isPatch;
 
   /**
    * Returns the element which defines the implementation for the entity of this
    * element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
-  Element get implementation => this;
+  Element get implementation => isPatched ? patch : this;
 
   /**
    * Returns the element which introduces the entity of this element.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
-  Element get declaration => this;
+  Element get declaration => isPatch ? origin : this;
 
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
   bool isTopLevel() {
     return enclosingElement !== null && enclosingElement.isCompilationUnit();
   }
 
   bool isAssignable() {
@@ skipping 21 matching lines @@
     while (element !== null && !element.isCompilationUnit()) {
       if (element is CompilationUnitOverrideElement) {
         CompilationUnitOverrideElement override = element;
         return override.compilationUnit;
       }
       if (element.isLibrary()) {
         LibraryElement library = element;
         return library.entryCompilationUnit;
       }
       element = element.enclosingElement;
-      if (element is FunctionElement) {
-        FunctionElement function = element;
-        if (function.isPatched) {
-          element = function.patch;
-        }
-      }
     }
     return element;
   }
 
-  LibraryElement getLibrary() {
+  LibraryElement getLibrary() => enclosingElement.getLibrary();
+
+  LibraryElement getImplementationLibrary() {
     Element element = this;
     while (element.kind !== ElementKind.LIBRARY) {
       element = element.enclosingElement;
     }
     return element;
   }
 
-  LibraryElement getImplementationLibrary() => getLibrary();
-
   ClassElement getEnclosingClass() {
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isClass()) return e;
     }
     return null;
   }
 
   Element getEnclosingClassOrCompilationUnit() {
    for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isClass() || e.isCompilationUnit()) return e;
@@ skipping 15 matching lines @@
         return e;
       }
     }
     return null;
   }
 
   /**
    * Creates the scope for this element. The scope of the
    * enclosing element will be the parent scope.
    */
-  Scope buildScope() => buildEnclosingScope();
+  // TODO(johnniwinther): Clean up scope generation. Possibly generation scopes
+  // externally.
+  Scope buildScope({bool patchScope: false}) =>
+      buildEnclosingScope(patchScope: patchScope);
 
   /**
    * Creates the scope for the enclosing element.
    */
-  Scope buildEnclosingScope() => enclosingElement.buildScope();
+  // TODO(johnniwinther): Remove buildEnclosingScope as part of scope clean-up.
+  Scope buildEnclosingScope({bool patchScope: false}) =>
+      enclosingElement.buildScope(patchScope: patchScope);
 
   String toString() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
     // invariant for all element types?
     var nameText = name !== null ? name.slowToString() : '?';
     if (enclosingElement !== null && !isTopLevel()) {
       String holderName = enclosingElement.name !== null
           ? enclosingElement.name.slowToString()
           : '${enclosingElement.kind}?';
       return '$kind($holderName#${nameText})';
     } else {
       return '$kind(${nameText})';
     }
   }
 
   bool _isNative = false;
   void setNative() { _isNative = true; }
   bool isNative() => _isNative;
 
   FunctionElement asFunctionElement() => null;
 
+  static bool isInvalid(Element e) => e == null || e.isErroneous();
   Element cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.cancel("Unimplemented cloneTo", element: this);
   }
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [null] to provide additional
  * information about the error that caused the element to be unresolvable
@@ skipping 82 matching lines @@
       Element existing = localScope.putIfAbsent(element.name, () => element);
       if (existing !== element) {
         // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
         listener.cancel('duplicate definition', token: element.position());
         listener.cancel('existing definition', token: existing.position());
       }
     }
   }
 
   Element localLookup(SourceString elementName) {
-    return localScope[elementName];
+    Element result = localScope[elementName];
+    if (result == null && isPatch) {
+      result = origin.localScope[elementName];
+    }
+    return result;
   }
 
   /**
    * Adds a definition for an [accessor] (getter or setter) to a container.
    * The definition binds to an abstract field that can hold both a getter
    * and a setter.
    *
    * The abstract field is added once, for the first getter or setter, and
    * reused if the other one is also added.
    * The abstract field should not be treated as a proper member of the
@@ skipping 52 matching lines @@
       super(new SourceString(script.name),
             ElementKind.COMPILATION_UNIT,
             library) {
     library.addCompilationUnit(this);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     // Keep a list of top level members.
     super.addMember(element, listener);
     // Provide the member to the library to build scope.
-    getLibrary().addMember(element, listener);
+    if (enclosingElement.isPatch) {
+      getImplementationLibrary().addMember(element, listener);
+    } else {
+      getLibrary().addMember(element, listener);
+    }
   }
 }
 
 class CompilationUnitOverrideElement extends Element {
   final CompilationUnitElement compilationUnit;
 
   CompilationUnitOverrideElement(CompilationUnitElement compilationUnit,
                                  Element enclosing)
       : this.compilationUnit = compilationUnit,
         super(compilationUnit.name,
               ElementKind.COMPILATION_UNIT_OVERRIDE,
               enclosing);
 }
 
 class LibraryElement extends ScopeContainerElement {
   final Uri uri;
   CompilationUnitElement entryCompilationUnit;
   Link<CompilationUnitElement> compilationUnits =
       const EmptyLink<CompilationUnitElement>();
   Link<LibraryTag> tags = const EmptyLink<LibraryTag>();
   LibraryTag libraryTag;
   bool canUseNative = false;
+
+  /**
+   * If this library is patched, [patch] points to the patch library.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
   LibraryElement patch = null;
 
   /**
+   * If this is a patch library, [origin] points to the origin library.
+   *
+   * See [:patch_parser.dart:] for a description of the terminology.
+   */
+  final LibraryElement origin;
+
+  /**
    * Map for elements imported through import declarations.
    *
    * Addition to the map is performed by [addImport]. Lookup is done trough
    * [find].
    */
   final Map<SourceString, Element> importScope;
 
-  LibraryElement(Script script, [Uri uri])
+  LibraryElement(Script script, [Uri uri, LibraryElement this.origin])
     : this.uri = ((uri === null) ? script.uri : uri),
       importScope = new Map<SourceString, Element>(),
       super(new SourceString(script.name), ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElement(script, this);
+    if (isPatch) {
+      origin.patch = this;
+    }
   }
 
+  bool get isPatched => patch !== null;
+  bool get isPatch => origin !== null;
 
-  bool get isPatched => patch !== null;
+  LibraryElement get declaration => super.declaration;
+  LibraryElement get implementation => super.implementation;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for the
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element element, DiagnosticListener listener) {
     Element existing = importScope.putIfAbsent(element.name, () => element);
     if (existing !== element && existing !== null) {
       if (!existing.isErroneous()) {
         // TODO(johnniwinther): Provide access to both the new and existing
         // elements.
         importScope[element.name] = new ErroneousElement(
             MessageKind.DUPLICATE_IMPORT,
             [element.name], element.name, this);
       }
     }
   }
 
+  LibraryElement getLibrary() => isPatch ? origin : this;
 
   /**
    * Look up a top-level element in this library. The element could
    * potentially have been imported from another library. Returns
    * null if no such element exist and an [ErroneousElement] if multiple
    * elements have been imported.
    */
   Element find(SourceString elementName) {
     Element result = localScope[elementName];
     if (result === null) {
       result = importScope[elementName];
     }
     return result;
   }
 
   /** Look up a top-level element in this library, but only look for
     * non-imported elements. Returns null if no such element exist. */
   Element findLocal(SourceString elementName) {
+    // TODO(johnniwinther): How to handle injected elements in the patch
+    // library?
     Element result = localScope[elementName];
     if (result === null || result.getLibrary() != this) return null;
     return result;
   }
 
   void forEachExport(f(Element element)) {
     localScope.forEach((_, Element e) {
       if (this === e.getLibrary()
           && e.kind !== ElementKind.PREFIX
           && e.kind !== ElementKind.FOREIGN
           && !e.name.isPrivate()) {
         f(e);
       }
     });
   }
 
+  void forEachLocalMember(f(Element element)) {
+    if (isPatch) {
+      // Patch libraries traverse both origin and injected members.
+      origin.localMembers.forEach(f);
+
+      void filterPatch(Element element) {
+        if (!element.isPatch) {
+          // Do not traverse the patch members.
+          f(element);
+        }
+      }
+      localMembers.forEach(filterPatch);
+    } else {
+      localMembers.forEach(f);
+    }
+  }
+
   bool hasLibraryName() => libraryTag !== null;
 
   /**
    * Returns the library name (as defined by the #library tag) or for script
    * (which have no #library tag) the script file name. The latter case is used
    * to private 'library name' for scripts to use for instance in dartdoc.
    */
   String getLibraryOrScriptName() {
     if (libraryTag !== null) {
       return libraryTag.argument.dartString.slowToString();
     } else {
       // Use the file name as script name.
       String path = uri.path;
       return path.substring(path.lastIndexOf('/') + 1);
     }
   }
 
-  Scope buildEnclosingScope() => new TopScope(this);
+  // TODO(johnniwinther): Rewrite to avoid the optional argument.
+  Scope buildEnclosingScope({bool patchScope: false}) {
+    if (origin !== null) {
+      return new PatchLibraryScope(origin, this);
+    } if (patchScope && patch !== null) {
+      return new PatchLibraryScope(this, patch);
+    } else {
+      return new TopScope(this);
+    }
+  }
 
   bool get isPlatformLibrary => uri.scheme == "dart";
+
+  String toString() {
+    if (origin !== null) {
+      return 'patch library(${getLibraryOrScriptName()})';
+    } else if (patch !== null) {
+      return 'origin library(${getLibraryOrScriptName()})';
+    } else {
+      return 'library(${getLibraryOrScriptName()})';
+    }
+  }
 }
 
 class PrefixElement extends Element {
   Map<SourceString, Element> imported;
   Token firstPosition;
 
   PrefixElement(SourceString prefix, Element enclosing, this.firstPosition)
       : imported = new Map<SourceString, Element>(),
         super(prefix, ElementKind.PREFIX, enclosing);
 
@@ skipping 34 matching lines @@
     Typedef node = parseNode(compiler);
     Link<DartType> parameters =
         TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
     cachedType = new TypedefType(this, parameters);
     compiler.resolveTypedef(this);
     return cachedType;
   }
 
   Link<DartType> get typeVariables => cachedType.typeArguments;
 
-  Scope buildScope() =>
-      new TypeDeclarationScope(enclosingElement.buildScope(), this);
+  // TODO(johnniwinther): Rewrite to avoid the optional argument.
+  Scope buildScope({bool patchScope: false}) {
+    return new TypeDeclarationScope(
+      enclosingElement.buildScope(patchScope: patchScope), this);
+  }
 
   TypedefElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypedefElement result = new TypedefElement(name, enclosing);
     return result;
   }
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
@@ skipping 140 matching lines @@
     } else {
       result = new VariableListElement(kind, modifiers, enclosing);
     }
     return result;
   }
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
-  Scope buildScope() {
-    Scope result = new VariableScope(enclosingElement.buildScope(), this);
+  // TODO(johnniwinther): Rewrite to avoid the optional argument.
+  Scope buildScope({bool patchScope: false}) {
+    Scope result = new VariableScope(
+        enclosingElement.buildScope(patchScope: patchScope), this);
     if (enclosingElement.isClass()) {
-      ClassScope clsScope = result.parent;
+      Scope clsScope = result.parent;
       clsScope.inStaticContext = !isInstanceMember();
     }
     return result;
   }
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name, ContainerElement enclosingElement)
     : super(name, ElementKind.FOREIGN, enclosingElement);
 
@@ skipping 130 matching lines @@
 
   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;
+  FunctionElement origin = 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,
@@ skipping 20 matching lines @@
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
     assert(modifiers !== null);
     defaultImplementation = this;
   }
 
   bool get isPatched => patch !== null;
+  bool get isPatch => origin !== 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);
     this.patch = patchElement;
-    cachedNode = patchElement.cachedNode;
   }
 
   bool isInstanceMember() {
     return isMember()
            && !isConstructor()
            && !modifiers.isStatic();
   }
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignature !== null) return functionSignature;
@@ skipping 16 matching lines @@
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     type = compiler.computeFunctionType(declaration,
                                         computeSignature(compiler));
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) {
-    if (cachedNode !== null) return cachedNode;
     if (patch === null) {
       if (modifiers.isExternal()) {
         listener.cancel("Compiling external function with no implementation.",
                         element: this);
       }
-      return null;
     }
-    cachedNode = patch.parseNode(listener);
     return cachedNode;
   }
 
   Token position() => cachedNode.getBeginToken();
 
   FunctionElement asFunctionElement() => this;
 
   String toString() {
     if (isPatch) {
       return 'patch ${super.toString()}';
     } else if (isPatched) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 
-  Scope buildScope() {
-    Scope result =
-        new MethodScope(enclosingElement.buildScope(), this);
+  // TODO(johnniwinther): Rewrite to avoid the optional argument.
+  Scope buildScope({bool patchScope: false}) {
+    Scope result = new MethodScope(
+        enclosingElement.buildScope(patchScope: patchScope), this);
     if (enclosingElement.isClass()) {
-      ClassScope clsScope = result.parent;
+      Scope clsScope = result.parent;
       clsScope.inStaticContext = !isInstanceMember() && !isConstructor();
     }
     return result;
   }
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
@@ skipping 103 matching lines @@
   int resolutionState;
 
   // 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<DartType> allSupertypes;
 
   // Lazily applied patch of class members.
   ClassElement patch = null;
+  ClassElement origin = null;
 
   ClassElement(SourceString name, Element enclosing, this.id, int initialState)
     : supertypeLoadState = initialState,
       resolutionState = initialState,
       super(name, ElementKind.CLASS, enclosing);
 
   InterfaceType computeType(compiler) {
     if (type == null) {
-      ClassNode node = parseNode(compiler);
-      Link<DartType> parameters =
-          TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
-      type = new InterfaceType(this, parameters);
+      if (origin === null) {
+        ClassNode node = parseNode(compiler);
+        Link<DartType> parameters =
+            TypeDeclarationElement.createTypeVariables(this,
+                                                       node.typeParameters);
+        type = new InterfaceType(this, parameters);
+      } else {
+        type = origin.computeType(compiler);
+      }
     }
     return type;
   }
 
   bool get isPatched => patch != null;
+  bool get isPatch => origin != null;
+
+  ClassElement get declaration => super.declaration;
+  ClassElement get implementation => super.implementation;
 
   /**
    * Return [:true:] if this element is the [:Object:] class for the [compiler].
    */
   bool isObject(Compiler compiler) =>
       declaration === compiler.objectClass;
 
   Link<DartType> get typeVariables => type.arguments;
 
   ClassElement ensureResolved(Compiler compiler) {
@@ skipping 18 matching lines @@
   Element lookupSuperMember(SourceString memberName) {
     return lookupSuperMemberInLibrary(memberName, getLibrary());
   }
 
   /**
    * Lookup super members for the class that is accessible in [library].
    * This will ignore constructors.
    */
   Element lookupSuperMemberInLibrary(SourceString memberName,
                                      LibraryElement library) {
+    bool includeInjectedMembers = isPatch;
     bool isPrivate = memberName.isPrivate();
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       // Private members from a different library are not visible.
       if (isPrivate && library !== s.getLibrary()) continue;
+      s = includeInjectedMembers ? s.implementation : s;
       Element e = s.lookupLocalMember(memberName);
       if (e === null) continue;
       // Static members are not inherited.
       if (e.modifiers.isStatic()) continue;
       return e;
     }
     if (isInterface()) {
       return lookupSuperInterfaceMember(memberName, getLibrary());
     }
     return null;
   }
 
   Element lookupSuperInterfaceMember(SourceString memberName,
                                      LibraryElement fromLibrary) {
+    bool includeInjectedMembers = isPatch;
     bool isPrivate = memberName.isPrivate();
     for (InterfaceType t in interfaces) {
       ClassElement cls = t.element;
+      cls = includeInjectedMembers ? cls.implementation : cls;
       Element e = cls.lookupLocalMember(memberName);
       if (e === null) continue;
       // Private members from a different library are not visible.
       if (isPrivate && fromLibrary !== e.getLibrary()) continue;
       // Static members are not inherited.
       if (e.modifiers.isStatic()) continue;
       return e;
     }
     return null;
   }
 
   /**
    * Find the first member in the class chain with the given [selector].
    *
    * This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
    * rules, where library scope comes before superclass scope.
+   *
+   * When called on the implementation element both members declared in the
+   * origin and the patch class are returned.
    */
   Element lookupSelector(Selector selector) {
     SourceString memberName = selector.name;
     LibraryElement library = selector.library;
     Element localMember = lookupLocalMember(memberName);
     if (localMember != null &&
         (!memberName.isPrivate() || getLibrary() == library)) {
       return localMember;
     }
     return lookupSuperMemberInLibrary(memberName, library);
@@ skipping 62 matching lines @@
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.getValues()) {
       if (element.isConstructor()) return true;
     }
     return false;
   }
 
   Link<Element> get constructors {
     // TODO(ajohnsen): See if we can avoid this method at some point.
     Link<Element> result = const EmptyLink<Element>();
-    for (Element member in localMembers) {
+    // TODO(johnniwinther): Should we include injected constructors?
+    forEachMember((_, Element member) {
       if (member.isConstructor()) result = result.prepend(member);
-    }
+    });
     return result;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass {
     assert(supertypeLoadState == STATE_DONE);
     return supertype === null ? null : supertype.element;
   }
 
   /**
    * Runs through all members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
+   *
+   * When called on an implementation element both the members in the origin
+   * and patch class are included.
    */
+  // TODO(johnniwinther): Clean up lookup to get rid of the include predicates.
   void forEachMember([void f(ClassElement enclosingClass, Element member),
                       includeBackendMembers = false,
                       includeSuperMembers = false]) {
+    bool includeInjectedMembers = isPatch;
     Set<ClassElement> seen = new Set<ClassElement>();
-    ClassElement classElement = this;
+    ClassElement classElement = declaration;
     do {
       if (seen.contains(classElement)) return;
       seen.add(classElement);
 
       // Iterate through the members in textual order, which requires
       // to reverse the data structure [localMembers] we created.
       // Textual order may be important for certain operations, for
       // example when emitting the initializers of fields.
       for (Element element in classElement.localMembers.reverse()) {
         f(classElement, element);
       }
       if (includeBackendMembers) {
         for (Element element in classElement.backendMembers) {
           f(classElement, element);
         }
       }
+      if (includeInjectedMembers) {
+        if (classElement.patch != null) {
+          for (Element element in classElement.patch.localMembers.reverse()) {
+            if (!element.isPatch) {
+              f(classElement, element);
+            }
+          }
+        }
+      }
       classElement = includeSuperMembers ? classElement.superclass : null;
     } while(classElement !== null);
   }
 
   /**
    * Runs through all instance-field members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
    *
    * When [includeBackendMembers] and [includeSuperMembers] are both [:true:]
    * then the fields are visited in the same order as they need to be given
    * to the JavaScript constructor.
+   *
+   * When called on the implementation element both the fields declared in the
+   * origin and in the patch are included.
    */
   void forEachInstanceField([void f(ClassElement enclosingClass, Element field),
                              includeBackendMembers = false,
                              includeSuperMembers = false]) {
     // Filters so that [f] is only invoked with instance fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
       if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
@@ skipping 22 matching lines @@
     for (ClassElement s = this; s != null; s = s.superclass) {
       if (s === cls) return true;
     }
     return false;
   }
 
   bool isInterface() => false;
   bool isNative() => nativeName != null;
   int hashCode() => id;
 
-  Scope buildScope() =>
-      new ClassScope(enclosingElement.buildScope(), this);
+  // TODO(johnniwinther): Rewrite to avoid the optional argument.
+  Scope buildScope({bool patchScope: false}) {
+    if (origin !== null) {
+      return new PatchClassScope(
+          enclosingElement.buildScope(patchScope: patchScope), origin, this);
+    } else if (patchScope && patch !== null) {
+      return new PatchClassScope(
+          enclosingElement.buildScope(patchScope: patchScope), this, patch);
+    } else {
+      return new ClassScope(
+          enclosingElement.buildScope(patchScope: patchScope), this);
+    }
+  }
+
+  Scope buildLocalScope() {
+    if (origin !== null) {
+      return new LocalPatchClassScope(origin, this);
+    } else {
+      return new LocalClassScope(this);
+    }
+  }
 
   ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.internalErrorOnElement(this, 'unsupported operation');
   }
 
   Link<DartType> get allSupertypesAndSelf {
     return allSupertypes.prepend(new InterfaceType(this));
   }
+
+  String toString() {
+    if (origin !== null) {
+      return 'patch ${super.toString()}';
+    } else if (patch !== null) {
+      return 'origin ${super.toString()}';
+    } else {
+      return super.toString();
+    }
+  }
 }
 
 class Elements {
   static bool isUnresolved(Element e) => e == null || e.isErroneous();
   static bool isErroneousElement(Element e) => e != null && e.isErroneous();
 
   static bool isLocal(Element element) {
     return !Elements.isUnresolved(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
@@ skipping 281 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }