Parse new library syntax.

dart/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.
 
 #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) {
     leg.Script script = compiler.readScript(patchUri, null);
     CompilationUnitElement compilationUnit =
         new CompilationUnitElement(script, library);
     library.addCompilationUnit(compilationUnit);
-    LinkBuilder<tree.ScriptTag> imports = new LinkBuilder<tree.ScriptTag>();
+    LinkBuilder<tree.LibraryTag> imports = new LinkBuilder<tree.LibraryTag>();
     compiler.withCurrentElement(compilationUnit, () {
       // 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);
     });
     // 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.ScriptTag tag in imports.toLink()) {
+    for (tree.LibraryTag tag in imports.toLink()) {
       compiler.scanner.importLibraryFromTag(tag, compilationUnit);
     }
   }
 
   void scanLibraryElements(
         CompilationUnitElement compilationUnit,
-        LinkBuilder<tree.ScriptTag> imports) {
+        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;
-    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;
+    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);
+      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;
+    }));
   }
 }
 
 /**
  * Extension of the [Listener] interface to handle the extra "patch" pseudo-
  * keyword in patch files.
  * Patch files shouldn't have a type named "patch".
  */
 abstract class PatchListener extends Listener {
   void beginPatch(Token patch);
@@ skipping 65 matching lines @@
 class PatchClassElementParser extends PatchParser {
   PatchClassElementParser(PatchListener listener) : super(listener);
 
   Token parseClassBody(Token token) => fullParseClassBody(token);
 }
 
 /**
  * Extension of [ElementListener] for parsing patch files.
  */
 class PatchElementListener extends ElementListener implements PatchListener {
-  final LinkBuilder<tree.ScriptTag> imports;
+  final LinkBuilder<tree.LibraryTag> imports;
   bool isMemberPatch = false;
   bool isClassPatch = false;
 
   PatchElementListener(leg.DiagnosticListener listener,
                        CompilationUnitElement patchElement,
                        int idGenerator(),
                        this.imports)
     : super(listener, patchElement, idGenerator);
 
   MetadataAnnotation popMetadata() {
@@ skipping 16 matching lines @@
       isClassPatch = false;
     } else {
       isMemberPatch = false;
     }
   }
 
   /**
     * Allow script tags (import only, the parser rejects the rest for now) in
     * patch files. The import tags will be added to the library.
     */
-  bool allowScriptTags() => true;
+  bool allowLibraryTags() => true;
 
-  void addScriptTag(tree.ScriptTag tag) {
-    super.addScriptTag(tag);
+  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);
       if (isMemberPatch) {
@@ skipping 81 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);
 }