Revert "Parse new library syntax."

dart/lib/compiler/implementation/scanner/scanner_task.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.
 
 class ScannerTask extends CompilerTask {
   ScannerTask(Compiler compiler) : super(compiler);
   String get name => 'Scanner';
 
   void scanLibrary(LibraryElement library) {
     var compilationUnit = library.entryCompilationUnit;
     compiler.log("scanning library ${compilationUnit.script.name}");
     scan(compilationUnit);
-    processLibraryTags(library);
+    processScriptTags(library);
   }
 
   void scan(CompilationUnitElement compilationUnit) {
     measure(() {
       scanElements(compilationUnit);
     });
   }
 
-  void processLibraryTags(LibraryElement library) {
+  void processScriptTags(LibraryElement library) {
     int tagState = TagState.NO_TAG_SEEN;
 
     /**
      * If [value] is less than [tagState] complain and return
      * [tagState]. Otherwise return the new value for [tagState]
      * (transition function for state machine).
      */
-    int checkTag(int value, LibraryTag tag) {
+    int checkTag(int value, ScriptTag tag) {
       if (tagState > value) {
         compiler.reportError(tag, 'out of order');
         return tagState;
       }
       return TagState.NEXT[value];
     }
 
-    LinkBuilder<Import> imports = new LinkBuilder<Import>();
+    LinkBuilder<ScriptTag> imports = new LinkBuilder<ScriptTag>();
     Uri base = library.entryCompilationUnit.script.uri;
-    for (LibraryTag tag in library.tags.reverse()) {
-      if (tag.isImport) {
+    for (ScriptTag tag in library.tags.reverse()) {
+      StringNode argument = tag.argument;
+      // TODO(lrn): Support interpolations here. We need access to the
+      // special constants that can be inserted into script tag strings.
+      Uri resolved = base.resolve(argument.dartString.slowToString());
+      if (tag.isImport()) {
         tagState = checkTag(TagState.IMPORT, tag);
         // It is not safe to import other libraries at this point as
         // another library could then observe the current library
         // before it fully declares all the members that are sourced
         // in.
         imports.addLast(tag);
-      } else if (tag.isLibraryName) {
+      } else if (tag.isLibrary()) {
         tagState = checkTag(TagState.LIBRARY, tag);
         if (library.libraryTag !== null) {
           compiler.cancel("duplicated library declaration", node: tag);
         } else {
           library.libraryTag = tag;
         }
-      } else if (tag.isPart) {
-        StringNode uri = tag.uri;
-        Uri resolved = base.resolve(uri.dartString.slowToString());
+      } else if (tag.isSource()) {
         tagState = checkTag(TagState.SOURCE, tag);
-        loadPart(tag, resolved, library);
+        importSourceFromTag(tag, resolved, library);
       } else {
         compiler.cancel("illegal script tag: ${tag.tag}", node: tag);
       }
     }
 
     // Apply patch, if any.
     if (library.uri.scheme == 'dart') {
       compiler.patchDartLibrary(library, library.uri.path);
     }
 
     // Now that we have processed all the source tags, it is safe to
     // start loading other libraries.
 
     if (library.uri.scheme != 'dart' || library.uri.path != 'core') {
       compiler.importCoreLibrary(library);
     }
 
-    for (Import tag in imports.toLink()) {
+    for (ScriptTag tag in imports.toLink()) {
       importLibraryFromTag(tag, library.entryCompilationUnit);
     }
   }
 
   /**
-   * Handle a part tag in the scope of [library]. The [path] given is used as
+   * Handle a source tag in the scope of [library]. The [path] given is used as
    * is, any resolution should be done beforehand.
    */
-  void loadPart(Part part, Uri path, LibraryElement library) {
-    Script sourceScript = compiler.readScript(path, part);
+  void importSourceFromTag(ScriptTag tag, Uri path, LibraryElement library) {
+    Script sourceScript = compiler.readScript(path, tag);
     CompilationUnitElement unit =
         new CompilationUnitElement(sourceScript, library);
     compiler.withCurrentElement(unit, () => compiler.scanner.scan(unit));
   }
 
   /**
    * Handle an import script tag by importing the referenced library into the
    * current library.
    * Returns the resolved library [Uri].
    */
-  Uri importLibraryFromTag(Import tag,
+  Uri importLibraryFromTag(ScriptTag tag,
                            CompilationUnitElement compilationUnit) {
     Uri base = compilationUnit.script.uri;
-    Uri resolved = base.resolve(tag.uri.dartString.slowToString());
-    LibraryElement importedLibrary = loadLibrary(resolved, tag.uri, resolved);
+    StringNode argument = tag.argument;
+    Uri resolved = base.resolve(argument.dartString.slowToString());
+    LibraryElement importedLibrary = loadLibrary(resolved, argument, resolved);
     importLibrary(compilationUnit.getLibrary(),
                   importedLibrary,
                   tag,
                   compilationUnit);
     return resolved;
   }
 
   void scanElements(CompilationUnitElement compilationUnit) {
     Script script = compilationUnit.script;
     Token tokens = new StringScanner(script.text).tokenize();
@@ skipping 13 matching lines @@
     if (newLibrary) {
       compiler.withCurrentElement(library, () {
         scanLibrary(library);
         compiler.onLibraryLoaded(library, uri);
       });
     }
     return library;
   }
 
   void importLibrary(LibraryElement library, LibraryElement imported,
-                     Import tag, [CompilationUnitElement compilationUnit]) {
+                     ScriptTag tag, [CompilationUnitElement compilationUnit]) {
     if (!imported.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
-        compiler.reportError(tag === null ? null : tag.uri,
+        compiler.reportError(tag === null ? null : tag.argument,
                              'no #library tag found in ${imported.uri}');
       });
     }
     if (tag !== null && tag.prefix !== null) {
-      SourceString prefix = tag.prefix.source;
+      SourceString prefix =
+          new SourceString(tag.prefix.dartString.slowToString());
       Element e = library.find(prefix);
       if (e === null) {
         if (compilationUnit === null) {
           compilationUnit = library.entryCompilationUnit;
         }
         e = new PrefixElement(prefix, compilationUnit, tag.getBeginToken());
         library.addToScope(e, compiler);
       }
       if (e.kind !== ElementKind.PREFIX) {
         compiler.withCurrentElement(e, () {
@@ skipping 54 matching lines @@
   static const int RESOURCE = 4;
 
   /** Next state. */
   static const List<int> NEXT =
       const <int>[NO_TAG_SEEN,
                   IMPORT, // Only one library tag is allowed.
                   IMPORT,
                   SOURCE,
                   RESOURCE];
 }