Internal libraries supported.

sdk/lib/_internal/compiler/implementation/library_loader.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.
 
 part of dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  */
 abstract class LibraryLoader extends CompilerTask {
@@ skipping 120 matching lines @@
   final Map<String, LibraryElement> libraryNames =
       new LinkedHashMap<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
   LibraryElement loadLibrary(Uri uri, Node node, Uri canonicalUri) {
     return measure(() {
       assert(currentHandler == null);
       currentHandler = new LibraryDependencyHandler(compiler);
       LibraryElement library =
-          createLibrary(currentHandler, uri, node, canonicalUri);
+          createLibrary(currentHandler, null, uri, node, canonicalUri);

[ngeoffray, 2013/01/16 15:40:57]

Why is that null here?

[Johnni Winther, 2013/01/21 09:27:54]

The importing uri. Since this is a load from the outside, there is no importing
uri, thus no access to internal libraries.

       currentHandler.computeExports();
       currentHandler = null;
       return library;
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
@@ skipping 86 matching lines @@
   }
 
   bool isDartCore(Uri uri) => uri.scheme == "dart" && uri.path == "core";
 
   /**
    * Lazily loads and returns the [LibraryElement] for the dart:core library.
    */
   LibraryElement loadCoreLibrary(LibraryDependencyHandler handler) {
     if (compiler.coreLibrary == null) {
       Uri coreUri = new Uri.fromComponents(scheme: 'dart', path: 'core');
-      compiler.coreLibrary = createLibrary(handler, coreUri, null, coreUri);
+      compiler.coreLibrary
+          = createLibrary(handler, null, coreUri, null, coreUri);

[ngeoffray, 2013/01/16 15:40:57]

ditto

[Johnni Winther, 2013/01/21 09:27:54]

The import is synthetic and we need no special access to load dart:core so the
import uri is null.

     }
     return compiler.coreLibrary;
   }
 
   void patchDartLibrary(LibraryDependencyHandler handler,
                         LibraryElement library, String dartLibraryPath) {
     if (library.isPatched) return;
     Uri patchUri = compiler.resolvePatchUri(dartLibraryPath);
     if (patchUri != null) {
       compiler.patchParser.patchLibrary(handler, patchUri, library);
@@ skipping 28 matching lines @@
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope.
    */
   void registerLibraryFromTag(LibraryDependencyHandler handler,
                               LibraryElement library,
                               LibraryDependency tag) {
+    Uri importingUri = library.uri;
     Uri base = library.entryCompilationUnit.script.uri;
     Uri resolved = base.resolve(tag.uri.dartString.slowToString());
     LibraryElement loadedLibrary =
-        createLibrary(handler, resolved, tag.uri, resolved);
+        createLibrary(handler, importingUri, resolved, tag.uri, resolved);
     handler.registerDependency(library, tag, loadedLibrary);
 
     if (!loadedLibrary.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
         compiler.reportError(tag == null ? null : tag.uri,
             'no library name found in ${loadedLibrary.uri}');
       });
     }
   }
 
   /**
-   * Create (or reuse) a library element for the library located at [uri].
+   * Create (or reuse) a library element for the library located at [scriptUri].
    * If a new library is created, the [handler] is notified.
    */
   LibraryElement createLibrary(LibraryDependencyHandler handler,
-                               Uri uri, Node node, Uri canonicalUri) {
+                               Uri importingUri,
+                               Uri scriptUri, Node node, Uri canonicalUri) {
     bool newLibrary = false;
+    Uri uri = compiler.resolveScriptUri(importingUri, scriptUri, node);
+    if (uri == null) return null;
     LibraryElement createLibrary() {
       newLibrary = true;
       Script script = compiler.readScript(uri, node);
       LibraryElement element = new LibraryElementX(script, canonicalUri);
       handler.registerNewLibrary(element);
-      native.maybeEnableNative(compiler, element, uri);
+      native.maybeEnableNative(compiler, element);
       return element;
     }
     LibraryElement library;
     if (canonicalUri == null) {
       library = createLibrary();
     } else {
       library = compiler.libraries.putIfAbsent(canonicalUri.toString(),
                                                createLibrary);
     }
     if (newLibrary) {
@@ skipping 379 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }