Internal libraries supported.

sdk/lib/_internal/compiler/implementation/apiimpl.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 leg_apiimpl;
 
 import 'dart:uri';
 import 'dart:async';
 
 import '../compiler.dart' as api;
@@ skipping 48 matching lines @@
         return option.substring('--force-strip='.length).split(',');
       }
     }
     return [];
   }
 
   static bool hasOption(List<String> options, String option) {
     return options.indexOf(option) >= 0;
   }
 
+  // TODO(johnniwinther): Merge better with [translateDartUri] when

[ahe, 2013/01/23 12:08:23]

I don't understand this comment.

[Johnni Winther, 2013/01/24 13:04:59]

The lookup into LIBRARIES is done both here and in [translateDartUri] which also
calls this method. I want to avoid that.

+  // [scanBuiltinLibrary] is removed.
   String lookupLibraryPath(String dartLibraryName) {
     LibraryInfo info = LIBRARIES[dartLibraryName];
     if (info == null) return null;
     if (!info.isDart2jsLibrary) return null;
     String path = info.dart2jsPath;
     if (path == null) {
       path = info.path;
     }
     return "lib/$path";
   }
 
   String lookupPatchPath(String dartLibraryName) {
     LibraryInfo info = LIBRARIES[dartLibraryName];
     if (info == null) return null;
     if (!info.isDart2jsLibrary) return null;
     String path = info.dart2jsPatchPath;
     if (path == null) return null;
     return "lib/$path";
   }
 
   elements.LibraryElement scanBuiltinLibrary(String path) {
     Uri uri = libraryRoot.resolve(lookupLibraryPath(path));
-    Uri canonicalUri = null;
-    if (!path.startsWith("_")) {
-      canonicalUri = new Uri.fromComponents(scheme: "dart", path: path);
-    }
+    Uri canonicalUri = new Uri.fromComponents(scheme: "dart", path: path);
     elements.LibraryElement library =
         libraryLoader.loadLibrary(uri, null, canonicalUri);
     return library;
   }
 
   void log(message) {
     handler(null, null, null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
-  leg.Script readScript(Uri uri, [tree.Node node]) {
+  Uri resolveAbsoluteUri(elements.LibraryElement importingLibrary,

[ahe, 2013/01/24 10:00:57]

Actually, this method name doesn't really make sense. In terms of URI RFC
(standard), resolving an absolute URI is a no-op. I'd rather call it
"translate".

[ahe, 2013/01/24 10:00:57]

I think it would be nice with a documentation comment like:

/// See [leg.Compiler.resolveAbsoluteUri].

Or something like that to inform the reader to look there for documentation.
When reading the library loader, it is nice to be able to go to leg.Compiler and
find documentation, but when reading this class, it's not so nice.

[Johnni Winther, 2013/01/24 13:04:59]

Done.

[Johnni Winther, 2013/01/24 13:04:59]

Good idea. Couldn't come up with a good name.

+                         Uri absoluteUri, tree.Node node) {
+    if (absoluteUri.scheme == 'dart') {
+      return translateDartUri(importingLibrary, absoluteUri, node);
+    }
+    return absoluteUri;
+  }
+
+  /**
+   * Reads the script designated by [readableUri].
+   */
+  leg.Script readScript(Uri readableUri, [tree.Node node]) {
+    if (!readableUri.isAbsolute()) {
+      internalError('Relative uri $readableUri provided to readScript(Uri)',
+                    node: node);
+    }
     return fileReadingTask.measure(() {
-      if (uri.scheme == 'dart') uri = translateDartUri(uri, node);
-      var translated = translateUri(uri, node);
+      Uri resourceUri = translateUri(readableUri, node);
       String text = "";
       try {
         // TODO(ahe): We expect the future to be complete and call value
         // directly. In effect, we don't support truly asynchronous API.
-        text = deprecatedFutureValue(provider(translated));
+        text = deprecatedFutureValue(provider(resourceUri));
       } catch (exception) {
         if (node != null) {
           cancel("$exception", node: node);
         } else {
           reportDiagnostic(null, "$exception", api.Diagnostic.ERROR);
           throw new leg.CompilerCancelledException("$exception");
         }
       }
-      SourceFile sourceFile = new SourceFile(translated.toString(), text);
-      return new leg.Script(uri, sourceFile);
+      SourceFile sourceFile = new SourceFile(resourceUri.toString(), text);
+      return new leg.Script(readableUri, sourceFile);

[ahe, 2013/01/24 10:00:57]

Do you know why we use the "readableUri" here? I still get two different
libraries if I use resourceUri when I import a package through different paths:

import 'package:foo/foo.dart' as a;
import 'packages/foo/foo.dart' as b;

[Johnni Winther, 2013/01/24 13:04:59]

We need to preserve the scheme in the script since is used for resolving
relative URIs mentioned in the script. Your example should result in two
different libraries (since the package root might not be the packages folder)
but importing 'foo.dart' in library 'a' must be the resolve to itself. That is,
the library loaded through the package scheme.

It was this subtlety that provoked the whole investigation into URIs.

     });
   }
 
-  Uri translateUri(Uri uri, tree.Node node) {
-    switch (uri.scheme) {
-      case 'package': return translatePackageUri(uri, node);
-      default: return uri;
+  /**
+   * Translates a readable URI into a resource URI.
+   *
+   * See [LibraryLoader] for terminology on URIs.
+   */
+  Uri translateUri(Uri readableUri, tree.Node node) {
+    switch (readableUri.scheme) {
+      case 'package': return translatePackageUri(readableUri, node);
+      default: return readableUri;
     }
   }
 
-  Uri translateDartUri(Uri uri, tree.Node node) {
-    String path = lookupLibraryPath(uri.path);
-    if (path == null || LIBRARIES[uri.path].category == "Internal") {
+  Uri translateDartUri(elements.LibraryElement importingLibrary,
+                       Uri absoluteUri, tree.Node node) {
+    LibraryInfo libraryInfo = LIBRARIES[absoluteUri.path];
+    String path = lookupLibraryPath(absoluteUri.path);
+    if (libraryInfo != null &&
+        libraryInfo.category == "Internal") {
+      bool allowInternalLibraryAccess = false;
+      if (importingLibrary != null) {
+        if (importingLibrary.isPlatformLibrary || importingLibrary.isPatch) {
+          allowInternalLibraryAccess = true;
+        } else if (importingLibrary.canonicalUri.path.contains(
+                       'dart/tests/compiler/dart2js_native')) {
+          allowInternalLibraryAccess = true;
+        }
+      }
+      if (!allowInternalLibraryAccess) {
+        if (node != null && importingLibrary != null) {
+          reportError(node,

[ahe, 2013/01/24 10:00:57]

Could this be reportDiagnostic?

[Johnni Winther, 2013/01/24 13:04:59]

Done.

+              'Internal library $absoluteUri is not accessible from '
+              '${importingLibrary.canonicalUri}');
+        } else {
+          reportError(null, 'Internal library $absoluteUri is not accessible');
+        }
+        path = null;

[ahe, 2013/01/24 10:00:57]

How about not setting path to null? The compiler will then resolve everything,
but stop before codegen.

[Johnni Winther, 2013/01/24 13:04:59]

Done.

+      }
+    }
+    if (path == null) {
       if (node != null) {
-        reportError(node, 'library not found ${uri}');
+        reportError(node, 'library not found ${absoluteUri}');
       } else {
-        reportDiagnostic(null, 'library not found ${uri}',
+        reportDiagnostic(null, 'library not found ${absoluteUri}',
                          api.Diagnostic.ERROR);
       }
       return null;
     }
-    if (uri.path == 'html' ||
-        uri.path == 'io') {
+    if (absoluteUri.path == 'html' ||
+        absoluteUri.path == 'io') {
       // TODO(ahe): Get rid of mockableLibraryUsed when test.dart
       // supports this use case better.
       mockableLibraryUsed = true;
     }
     return libraryRoot.resolve(path);
   }
 
   Uri resolvePatchUri(String dartLibraryPath) {
     String patchPath = lookupPatchPath(dartLibraryPath);
     if (patchPath == null) return null;
@@ skipping 29 matching lines @@
       handler(translateUri(span.uri, null), span.begin, span.end,
               message, kind);
     }
   }
 
   bool get isMockCompilation {
     return mockableLibraryUsed
       && (options.indexOf('--allow-mock-compilation') != -1);
   }
 }