Patch refactoring.

lib/compiler/implementation/patch_parser.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.
 
 /**
- * TODO(johnniwinther): The terminology and invariants described below will not
- * hold until CL 10905305 has been committed.
- *
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
  * patched is determined by the [dart2jsPatchPath] field of [LibraryInfo] found
  * in [:lib/_internal/libraries.dart:].
  *
  * Patch libraries are parsed like regular library and thus provided with their
  * own elements. These elements which are distinct from the elements from the
@@ skipping 35 matching lines @@
  *     class RegularClass { // A regular class.
  *       void regularMethod() {} // A regular method.
  *     }
  *     class PatchedClass { // An origin class.
  *       int regularField; // A regular field.
  *       void regularMethod() {} // A regular method.
  *       external void patchedMethod(); // An origin method.
  *     }
  *
  *     // In the patch library:
- *     class _GhostClass { // A ghost class.
- *       void _ghostMethod() {} // A ghost method.
+ *     class _InjectedClass { // An injected class.
+ *       void _injectedMethod() {} // An injected method.
  *     }
  *     patch class PatchedClass { // A patch class.
- *       int _ghostField; { // A ghost field.
+ *       int _injectedField; { // An injected field.
  *       patch void patchedMethod() {} // A patch method.
  *     }
  *
  *
  * ## Declaration and Implementation ##
  *
  * With patches we have two views on elements: as the 'declaration' which
  * introduces the entity and defines its interface, and as the 'implementation'
  * which defines the actual implementation of the entity.
  *
  * Every element has a 'declaration' and an 'implementation' element. For
- * regular and ghost elements these are the same. For origin elements the
+ * regular and injected elements these are the same. For origin elements the
  * declaration is the element itself and the implementation is the patch element
  * found through its [:patch:] field. For patch elements the implementation is
  * the element itself and the declaration is the origin element found through
  * its [:origin:] field. The declaration and implementation of any element is
  * conveniently available through the [Element.declaration] and
  * [Element.implementation] getters.
  *
  * Most patch-related invariants enforced through-out the compiler are defined
  * in terms of 'declaration' and 'implementation', and tested through the
  * predicate getters [Element.isDeclaration] and [Element.isImplementation].
  * Patch invariants are stated both in comments and as assertions.
  *
  *
  * ## General invariant guidelines ##
  *
  * For [LibraryElement] we always use declarations. This means the
  * [Element.getLibrary] method will only return library declarations. Patch
  * library implementations are only accessed through calls to
  * [Element.getImplementationLibrary] which is used to setup the correct
- * [Element.enclosingElement] relation between patch/ghost elements and the
+ * [Element.enclosingElement] relation between patch/injected elements and the
  * patch library.
  *
  * For [ClassElement] and [FunctionElement] we use declarations for determining
  * identity and implementations for work based on the AST nodes, such as
  * resolution, type-checking, type inference, building SSA graphs, etc.
  * - Worklist only contain declaration elements.
  * - Most maps and sets use declarations exclusively, and their individual
  *   invariants are stated in the field comments.
  * - [TreeElements] only map to patch elements from inside a patch library.
+ *   TODO(johnniwinther): Simplify this invariant to use only declarations in
+ *   [TreeElements].
  * - Builders shift between declaration and implementation depending on usages.
  * - Compile-time constants use constructor implementation exclusively.
  * - Work on function parameters is performed on the declaration of the function
  *   element.
  */
 #library("patchparser");
 
 #import("dart:uri");
 #import("tree/tree.dart", prefix: "tree");
 #import("leg.dart", prefix: 'leg');  // CompilerTask, Compiler.
 #import("apiimpl.dart");
 #import("scanner/scannerlib.dart");  // Scanner, Parsers, Listeners
 #import("elements/elements.dart");
 #import('util/util.dart');
 
 class PatchParserTask extends leg.CompilerTask {
   PatchParserTask(leg.Compiler compiler): super(compiler);
   final String name = "Patching Parser";
 
   /**
    * Scans a library patch file, applies the method patches and
    * injections to the library, and returns a list of class
    * patches.
    */
-  void patchLibrary(Uri patchUri, LibraryElement library) {
+  void patchLibrary(Uri patchUri, LibraryElement originLibrary) {
     leg.Script script = compiler.readScript(patchUri, null);
-    CompilationUnitElement compilationUnit =
-        new CompilationUnitElement(script, library);
+    var patchLibrary = new LibraryElement(script, patchUri, originLibrary);
     LinkBuilder<tree.LibraryTag> imports = new LinkBuilder<tree.LibraryTag>();
-    compiler.withCurrentElement(compilationUnit, () {
+    compiler.withCurrentElement(patchLibrary.entryCompilationUnit, () {
       // This patches the elements of the patch library into [library].
       // Injected elements are added directly under the compilation unit.
       // Patch elements are stored on the patched functions or classes.
-      scanLibraryElements(compilationUnit, imports);
+      scanLibraryElements(patchLibrary.entryCompilationUnit, imports);
     });
     // After scanning declarations, we handle the import tags in the patch.
     // TODO(lrn): These imports end up in the original library and are in
     // scope for the original methods too. This should be fixed.
     for (tree.LibraryTag tag in imports.toLink()) {
-      compiler.scanner.importLibraryFromTag(tag, compilationUnit);
+      compiler.scanner.importLibraryFromTag(tag,
+                                            patchLibrary.entryCompilationUnit);
     }
   }
 
   void scanLibraryElements(
         CompilationUnitElement compilationUnit,
         LinkBuilder<tree.LibraryTag> imports) {
     measure(() {
       // TODO(lrn): Possibly recursively handle #source directives in patch.
       leg.Script script = compilationUnit.script;
       Token tokens = new StringScanner(script.text).tokenize();
       Function idGenerator = compiler.getNextFreeClassId;
       PatchListener patchListener =
           new PatchElementListener(compiler,
                                    compilationUnit,
                                    idGenerator,
                                    imports);
       new PatchParser(patchListener).parseUnit(tokens);
     });
   }
 
   tree.ClassNode parsePatchClassNode(PartialClassElement element) {
+    // Parse [PartialClassElement] using a "patch"-aware parser instead
+    // of calling its [parseNode] method.
+    if (element.cachedNode != null) return element.cachedNode;
+
     return measure(() => compiler.withCurrentElement(element, () {
-      // Parse [PartialClassElement] using a "patch"-aware parser instead
-      // of calling its [parseNode] method.
-      if (element.cachedNode != null) return element.cachedNode;
-      PatchMemberListener listener =
-          new PatchMemberListener(compiler, element);
+      PatchMemberListener listener = new PatchMemberListener(compiler, element);
       Parser parser = new PatchClassElementParser(listener);
       Token token = parser.parseTopLevelDeclaration(element.beginToken);
       assert(token === element.endToken.next);
       element.cachedNode = listener.popNode();
       assert(listener.nodes.isEmpty());
       return element.cachedNode;
     }));
   }
 }
 
@@ skipping 120 matching lines @@
 
   void addLibraryTag(tree.LibraryTag tag) {
     super.addLibraryTag(tag);
     imports.addLast(tag);
   }
 
   void pushElement(Element element) {
     if (isMemberPatch || (isClassPatch && element is ClassElement)) {
       // Apply patch.
       element.addMetadata(popMetadata());
-      LibraryElement library = compilationUnitElement.getLibrary();
-      Element existing = library.localLookup(element.name);
+      LibraryElement originLibrary = compilationUnitElement.getLibrary();
+      assert(originLibrary.isPatched);
+      Element existing = originLibrary.localLookup(element.name);
       if (isMemberPatch) {
         if (element is! FunctionElement) {
           listener.internalErrorOnElement(element,
                                           "Member patch is not a function.");
         }
         if (existing.kind === ElementKind.ABSTRACT_FIELD) {
           if (!element.isAccessor()) {
             listener.internalErrorOnElement(
                 element, "Patching non-accessor with accessor");
           }
           AbstractFieldElement field = existing;
           if (element.isGetter()) {
             existing = field.getter;
           } else {
             existing = field.setter;
           }
         }
         if (existing is! FunctionElement) {
           listener.internalErrorOnElement(element,
                                           "No corresponding method for patch.");
         }
         FunctionElement function = existing;
         if (function.isPatched) {
           listener.internalErrorOnElement(
               element, "Patching the same function more than once.");
         }
         function.patch = element;
+        element.origin = function;
       } else {
         if (existing is! ClassElement) {
           listener.internalErrorOnElement(
               element, "Patching a non-class with a class patch.");
         }
         ClassElement classElement = existing;
         if (classElement.isPatched) {
           listener.internalErrorOnElement(
               element, "Patching the same class more than once.");
         }
         classElement.patch = element;
+        element.origin = classElement;
       }
-      return;
     }
     super.pushElement(element);
   }
 }
 
 /**
  * Extension of [MemberListener] for parsing patch class bodies.
  */
 class PatchMemberListener extends MemberListener implements PatchListener {
   bool isMemberPatch = false;
@@ skipping 32 matching lines @@
     super.addMember(element);
   }
 }
 
 // TODO(ahe): Get rid of this class.
 class PatchMetadataAnnotation extends MetadataAnnotation {
   final leg.Constant value = null;
 
   PatchMetadataAnnotation() : super(STATE_DONE);
 }