Make top-level patch injections be compilation unit under library.

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;
@@ skipping 18 matching lines @@
      */
     int checkTag(int value, ScriptTag tag) {
       if (tagState > value) {
         compiler.reportError(tag, 'out of order');
         return tagState;
       }
       return TagState.NEXT[value];
     }
 
     LinkBuilder<ScriptTag> imports = new LinkBuilder<ScriptTag>();
-    Uri base = library.uri;
+    Uri base = library.entryCompilationUnit.script.uri;
     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
@@ skipping 12 matching lines @@
         CompilationUnitElement unit =
             new CompilationUnitElement(script, library);
         compiler.withCurrentElement(unit, () => scan(unit));
       } else if (tag.isResource()) {
         tagState = checkTag(TagState.RESOURCE, tag);
         compiler.reportWarning(tag, 'ignoring resource tag');
       } 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.
+
     // TODO(ahe): During Compiler.scanBuiltinLibraries,
     // compiler.coreLibrary is null. Clean this up when there is a
     // better way to access "dart:core".
     bool implicitlyImportCoreLibrary = compiler.coreLibrary !== null;
+
     for (ScriptTag tag in imports.toLink()) {
-      // Now that we have processed all the source tags, it is safe to
-      // start loading other libraries.
-      StringNode argument = tag.argument;
-      Uri resolved = base.resolve(argument.dartString.slowToString());
-      if (resolved.toString() == "dart:core") {
+      Uri resolvedUri =
+          importLibraryFromTag(tag, library.entryCompilationUnit);
+      if (resolvedUri.toString() == "dart:core") {
         implicitlyImportCoreLibrary = false;
       }
-      LibraryElement importedLibrary = loadLibrary(resolved, argument);
-      importLibrary(library, importedLibrary, tag);
-      if (resolved.scheme == "dart") {
-        compiler.patchDartLibrary(importedLibrary, resolved.path);
-      }
     }
     if (implicitlyImportCoreLibrary) {
       importLibrary(library, compiler.coreLibrary, null);
     }
   }
 
+  /**
+   * Handle an import script tag by importing the referenced library into the
+   * current library.
+   * Returns the resolved library [Uri].
+   */
+  Uri importLibraryFromTag(ScriptTag tag,
+                           CompilationUnitElement compilationUnit) {
+    Uri base = compilationUnit.script.uri;
+    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;
     try {
       tokens = new StringScanner(script.text).tokenize();
     } catch (MalformedInputException ex) {
       Token token;
       var message;
       if (ex.position is num) {
         // TODO(ahe): Always use tokens in MalformedInputException.
         token = new Token(EOF_INFO, ex.position);
       } else {
         token = ex.position;
       }
       compiler.cancel(ex.message, token: token);
     }
     compiler.dietParser.dietParse(compilationUnit, tokens);
   }
 
-  LibraryElement loadLibrary(Uri uri, Node node) {
+  LibraryElement loadLibrary(Uri uri, Node node, Uri canonicalUri) {
     bool newLibrary = false;
     LibraryElement library =
       compiler.libraries.putIfAbsent(uri.toString(), () {
           newLibrary = true;
           Script script = compiler.readScript(uri, node);
-          LibraryElement element = new LibraryElement(script);
+          LibraryElement element = new LibraryElement(script, canonicalUri);
           native.maybeEnableNative(compiler, element, uri);
           return element;
         });
     if (newLibrary) {
       compiler.withCurrentElement(library, () {
         scanLibrary(library);
         compiler.onLibraryLoaded(library, uri);
       });
     }
     return library;
   }
 
   void importLibrary(LibraryElement library, LibraryElement imported,
-                     ScriptTag tag, [CompilationUnitElement override]) {
+                     ScriptTag tag, [CompilationUnitElement compilationUnit]) {
     if (!imported.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
         compiler.reportError(tag === null ? null : tag.argument,
                              'no #library tag found in ${imported.uri}');
       });
     }
     if (tag !== null && tag.prefix !== null) {
       SourceString prefix =
           new SourceString(tag.prefix.dartString.slowToString());
       Element e = library.find(prefix);
       if (e === null) {
-        Element enclosing = library;
-        if (override !== null) {
-          enclosing = new CompilationUnitOverrideElement(override, library);
+        if (compilationUnit === null) {
+          compilationUnit = library.entryCompilationUnit;
         }
-        e = new PrefixElement(prefix, enclosing, tag.getBeginToken());
+        e = new PrefixElement(prefix, compilationUnit, tag.getBeginToken());
         library.addToScope(e, compiler);
       }
       if (e.kind !== ElementKind.PREFIX) {
         compiler.withCurrentElement(e, () {
           compiler.reportWarning(new Identifier(e.position()),
                                  'duplicated definition');
         });
         compiler.reportError(tag.prefix, 'duplicate defintion');
       }
       PrefixElement prefixElement = e;
@@ skipping 48 matching lines @@
   static final int RESOURCE = 4;
 
   /** Next state. */
   static final List<int> NEXT =
       const <int>[NO_TAG_SEEN,
                   IMPORT, // Only one library tag is allowed.
                   IMPORT,
                   SOURCE,
                   RESOURCE];
 }