Add package config support to dart:isolate

runtime/bin/builtin.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 builtin;
 // NOTE: Do not import 'dart:io' in builtin.
 import 'dart:async';
 import 'dart:collection';
 import 'dart:_internal';
 import 'dart:isolate';
@@ skipping 71 matching lines @@
 
 // The current working directory when the embedder was launched.
 Uri _workingDirectory;
 // The URI that the root script was loaded from. Remembered so that
 // package imports can be resolved relative to it. The root script is the basis
 // for the root library in the VM.
 Uri _rootScript;
 
 // Packages are either resolved looking up in a map or resolved from within a
 // package root.
-bool _packagesReady() => (_packageRoot != null) || (_packageMap != null);
+bool get _packagesReady =>
+    (_packageRoot != null) || (_packageMap != null) || (_packageError != null);
+// Error string set if there was an error resolving package configuration.
+// For example not finding a .packages file or packages/ directory, malformed
+// .packages file or any other related error.
+String _packageError = null;
 // The directory to look in to resolve "package:" scheme URIs. By detault it is
 // the 'packages' directory right next to the script.
 Uri _packageRoot = null; // Used to be _rootScript.resolve('packages/');
 // The map describing how certain package names are mapped to Uris.
+Uri _packageConfig = null;
 Map<String, Uri> _packageMap = null;
+
 // A list of pending packags which have been requested while resolving the
 // location of the package root or the contents of the package map.
 List<_LoadRequest> _pendingPackageLoads = [];
 
 // If we have outstanding loads or pending package loads waiting for resolution,
 // then we do have pending loads.
 bool _pendingLoads() => !_reqMap.isEmpty || !_pendingPackageLoads.isEmpty;
 
 // Special handling for Windows paths so that they are compatible with URI
 // handling.
 // Embedder sets this to true if we are running on Windows.
 bool _isWindows = false;
 
 // Logging from builtin.dart is prefixed with a '*'.
+String _logId = (Isolate.current.hashCode % 0x100000).toRadixString(16);
 _log(msg) {
-  _print("* $msg");
+  _print("* $_logId $msg");
 }
 
 // A class wrapping the load error message in an Error object.
 class _LoadError extends Error {
   final String message;
   final String uri;
   _LoadError(this.uri, this.message);
 
   String toString() => 'Load Error for "$uri": $message';
 }
@@ skipping 104 matching lines @@
   if (packageRoot.startsWith('file:') ||
       packageRoot.startsWith('http:') ||
       packageRoot.startsWith('https:')) {
     _packageRoot = _workingDirectory.resolve(packageRoot);
   } else {
     packageRoot = _sanitizeWindowsPath(packageRoot);
     packageRoot = _trimWindowsPath(packageRoot);
     _packageRoot = _workingDirectory.resolveUri(new Uri.file(packageRoot));
   }
   // Now that we have determined the packageRoot value being used, set it
-  // up for use in Platform.packageRoot.
-  VMLibraryHooks.packageRoot = _packageRoot.toString();
+  // up for use in Platform.packageRoot. This is only set when the embedder
+  // sets up the package root. Automatically discovered package root will
+  // not update the VMLibraryHooks value.
+  VMLibraryHooks.packageRootString = _packageRoot.toString();
   if (_traceLoading) {
     _log('Package root URI: $_packageRoot');
   }
 }
 
 
 // Given a uri with a 'package' scheme, return a Uri that is prefixed with
 // the package root.
 Uri _resolvePackageUri(Uri uri) {
+  assert(uri.scheme == "package");
+  assert(_packagesReady);
+
   if (!uri.host.isEmpty) {
     var path = '${uri.host}${uri.path}';
     var right = 'package:$path';
     var wrong = 'package://$path';
 
     throw "URIs using the 'package:' scheme should look like "
           "'$right', not '$wrong'.";
   }
 
   if (_traceLoading) {
     _log('Resolving package with uri path: ${uri.path}');
   }
   var resolvedUri;
-  if (_packageRoot != null) {
+  if (_packageError != null) {
+    if (_traceLoading) {
+      _log("Resolving package with pending resolution error: $_packageError");
+    }
+    throw _packageError;
+  } else if (_packageRoot != null) {
     resolvedUri = _packageRoot.resolve(uri.path);
   } else {
     var packageName = uri.pathSegments[0];
     var mapping = _packageMap[packageName];
     if (_traceLoading) {
       _log("Mapped '$packageName' package to '$mapping'");
     }
     if (mapping == null) {
       throw "No mapping for '$packageName' package when resolving '$uri'.";
     }
@@ skipping 128 matching lines @@
   _packagesPort.close();
   _packagesPort = null;
 
   if (_traceLoading) {
     _log("Got packages reply: $msg");
   }
   if (msg is String) {
     if (_traceLoading) {
       _log("Got failure response on package port: '$msg'");
     }
-    throw msg;
-  }
-  if (msg.length == 1) {
+    // Remember the error message.
+    _packageError = msg;
+  } else if (msg is List) {
+    if (msg.length == 1) {
+      if (_traceLoading) {
+        _log("Received package root: '${msg[0]}'");
+      }
+      _packageRoot = Uri.parse(msg[0]);
+    } else {
+      // First entry contains the location of the loaded .packages file.
+      assert((msg.length % 2) == 0);
+      assert(msg.length >= 2);
+      assert(msg[1] == null);
+      _packageConfig = Uri.parse(msg[0]);
+      _packageMap = new Map<String, Uri>();
+      for (var i = 2; i < msg.length; i+=2) {
+        // TODO(iposva): Complain about duplicate entries.
+        _packageMap[msg[i]] = Uri.parse(msg[i+1]);
+      }
+      if (_traceLoading) {
+        _log("Setup package map: $_packageMap");
+      }
+    }
+  } else {
+    _packageError = "Bad type of packages reply: ${msg.runtimeType}";
     if (_traceLoading) {
-      _log("Received package root: '${msg[0]}'");
-    }
-    _packageRoot = Uri.parse(msg[0]);
-  } else {
-    assert((msg.length % 2) == 0);
-    _packageMap = new Map<String, Uri>();
-    for (var i = 0; i < msg.length; i+=2) {
-      // TODO(iposva): Complain about duplicate entries.
-      _packageMap[msg[i]] = Uri.parse(msg[i+1]);
-    }
-    if (_traceLoading) {
-      _log("Setup package map: $_packageMap");
+      _log(_packageError);
     }
   }
 
   // Resolve all pending package loads now that we know how to resolve them.
   while (_pendingPackageLoads.length > 0) {
     // Order does not matter as we queue all of the requests up right now.
     var req = _pendingPackageLoads.removeLast();
     // Call the registered closure, to handle the delayed action.
     req();
   }
@@ skipping 41 matching lines @@
   if (_workingDirectory == null) {
     throw 'No current working directory set.';
   }
   var packagesName = _sanitizeWindowsPath(packagesParam);
   var packagesUri = Uri.parse(packagesName);
   if (packagesUri.scheme == '') {
     // Script does not have a scheme, assume that it is a path,
     // resolve it against the working directory.
     packagesUri = _workingDirectory.resolveUri(packagesUri);
   }
-  VMLibraryHooks.packageConfig = packagesUri.toString();
+  var packagesUriStr = packagesUri.toString();
+  VMLibraryHooks.packageConfigString = packagesUriStr;
   if (_traceLoading) {
     _log('Resolved packages map to: $packagesUri');
   }
 
   // Request the loading and parsing of the packages map at the specified URI.
   // Create a port to receive the packages map on.
   assert(_packagesPort == null);
   _packagesPort = new RawReceivePort(_handlePackagesReply);
   var sp = _packagesPort.sendPort;
 
   var msg = new List(4);
   msg[0] = sp;
   msg[1] = _traceLoading;
   msg[2] = -2;
-  msg[3] = packagesUri.toString();
+  msg[3] = packagesUriStr;
   _loadPort.send(msg);
 
   // Signal that the resolution of the packages map has started. But in this
   // case it is not tied to a particular request.
   _pendingPackageLoads.add(() {
     // Nothing to be done beyond registering that there is pending package
     // resolution requested by having an empty entry.
     if (_traceLoading) {
       _log("Skipping dummy deferred request.");
     }
   });
 
   if (_traceLoading) {
     _log("Requested packages map at '$packagesUri'.");
   }
 }
 
 
-// Embedder Entrypoint:
-// Add mapping from package name to URI.
-void _addPackageMapEntry(String key, String value) {
-  if (!_setupCompleted) {
-    _setupHooks();
-  }
-  if (_traceLoading) {
-    _log("Adding packages map entry: $key -> $value");
-  }
-  if (_packageRoot != null) {
-    if (_traceLoading) {
-      _log("_packageRoot already set: $_packageRoot");
-    }
-    throw "Cannot add package map entry to an exisiting package root.";
-  }
-  if (_packagesPort != null) {
-    if (_traceLoading) {
-      _log("Package map load request already pending.");
-    }
-    throw "Cannot add package map entry during package map resolution.";
-  }
-  if (_packageMap == null) {
-    _packageMap = new Map<String, Uri>();
-  }
-  _packageMap[key] = _workingDirectory.resolve(value);
-}
-
-
 void _asyncLoadError(_LoadRequest req, _LoadError error, StackTrace stack) {
   if (_traceLoading) {
     _log("_asyncLoadError(${req._uri}), error: $error\nstack: $stack");
   }
   if (req._tag == _Dart_kResourceLoad) {
     Completer c = req._context;
     c.completeError(error, stack);
   } else {
     String libraryUri = req._context;
     if (req._tag == _Dart_kImportTag) {
@@ skipping 20 matching lines @@
     // Register a dummy load request and fail to load it.
     var req = new _LoadRequest(tag, uri, resourceUri, context);
     _asyncLoadError(req, error, s);
   }
 }
 
 
 // Loading a package URI needs to first map the package name to a loadable
 // URI.
 _loadPackage(int tag, String uri, Uri resourceUri, context) {
-  if (_packagesReady()) {
-    _loadData(tag, uri, _resolvePackageUri(resourceUri), context);
+  if (_packagesReady) {
+    var resolvedUri;
+    try {
+      resolvedUri = _resolvePackageUri(resourceUri);
+    } catch (e, s) {
+      if (_traceLoading) {
+        _log("Exception ($e) when resolving package URI: $resourceUri");
+      }
+      // Wrap inside a _LoadError unless we are already propagating a previously
+      // seen _LoadError.
+      var error = (e is _LoadError) ? e : new _LoadError(uri, e.toString());
+      // Register a dummy load request and fail to load it.
+      var req = new _LoadRequest(tag, uri, resourceUri, context);
+      _asyncLoadError(req, error, s);
+    }
+    _loadData(tag, uri, resolvedUri, context);
   } else {
     if (_pendingPackageLoads.isEmpty) {
       // Package resolution has not been setup yet, and this is the first
       // request for package resolution & loading.
       _requestPackagesMap();
     }
     // Register the action of loading this package once the package resolution
     // is ready.
     _pendingPackageLoads.add(() {
       if (_traceLoading) {
         _log("Handling deferred package request: "
              "$tag, $uri, $resourceUri, $context");
       }
       _loadPackage(tag, uri, resourceUri, context);
     });
     if (_traceLoading) {
       _log("Pending package load of '$uri': "
-      "${_pendingPackageLoads.length} pending");
+           "${_pendingPackageLoads.length} pending");
     }
   }
 }
 
 
 // Load the data associated with the resourceUri.
 _loadData(int tag, String uri, Uri resourceUri, context) {
   if (resourceUri.scheme == 'package') {
     // package based uris need to be resolved to the correct loadable location.
     // The logic of which is handled seperately, and then _loadData is called
@@ skipping 42 matching lines @@
   }
   if (_traceLoading) {
     _log('Resolved $userString in $base to $result');
   }
   return result;
 }
 
 
 // Handling of access to the package root or package map from user code.
 _triggerPackageResolution(action) {
-  if (_packagesReady()) {
+  if (_packagesReady) {
     // Packages are ready. Execute the action now.
     action();
   } else {
     if (_pendingPackageLoads.isEmpty) {
       // Package resolution has not been setup yet, and this is the first
       // request for package resolution & loading.
       _requestPackagesMap();
     }
     // Register the action for when the package resolution is ready.
     _pendingPackageLoads.add(action);
   }
 }
 
 
-Future<Uri> _getPackageRoot() {
+Future<Uri> _getPackageRootFuture() {
   if (_traceLoading) {
     _log("Request for package root from user code.");
   }
   var completer = new Completer<Uri>();
   _triggerPackageResolution(() {
     completer.complete(_packageRoot);
   });
   return completer.future;
 }
 
 
-Future<Map<String, Uri>> _getPackageMap() {
+Future<Uri> _getPackageConfigFuture() {
   if (_traceLoading) {
-    _log("Request for package map from user code.");
+    _log("Request for package config from user code.");
   }
-  var completer = new Completer<Map<String, Uri>>();
+  var completer = new Completer<Uri>();
   _triggerPackageResolution(() {
-    var result = (_packageMap != null) ? new Map.from(_packageMap) : {};
-    completer.complete(result);
+    completer.complete(_packageConfig);
   });
   return completer.future;
 }
 
 
+Future<Uri> _resolvePackageUriFuture(Uri packageUri) async {
+  if (_traceLoading) {
+    _log("Request for package Uri resolution from user code: $packageUri");
+  }
+  if (packageUri.scheme != "package") {
+    if (_traceLoading) {
+      _log("Non-package Uri, returning unmodified: $packageUri");
+    }
+    // Return the incoming parameter if not passed a package: URI.
+    return packageUri;
+  }
+
+  if (!_packagesReady) {
+    if (_traceLoading) {
+      _log("Trigger loading by requesting the package config.");
+    }
+    // Make sure to trigger package resolution.
+    var dummy = await _getPackageConfigFuture();
+  }
+  assert(_packagesReady);
+
+  var result = _resolvePackageUri(packageUri);
+  if (_traceLoading) {
+    _log("Resolved '$packageUri' to '$result'");
+  }
+  return result;
+}
+
+
 // Handling of Resource class by dispatching to the load port.
 Future<List<int>> _resourceReadAsBytes(Uri uri) {
   var completer = new Completer<List<int>>();
   // Request the load of the resource associating the completer as the context
   // for the load.
   _loadData(_Dart_kResourceLoad, uri.toString(), uri, completer);
   // Return the future that will be triggered once the resource has been loaded.
   return completer.future;
 }
 
@@ skipping 107 matching lines @@
   var filename = _platformExtensionFileName(name);
 
   return [path, filename, name];
 }
 
 
 // Register callbacks and hooks with the rest of the core libraries.
 _setupHooks() {
   _setupCompleted = true;
   VMLibraryHooks.resourceReadAsBytes = _resourceReadAsBytes;
-  VMLibraryHooks.getPackageRoot = _getPackageRoot;
-  VMLibraryHooks.getPackageMap = _getPackageMap;
+
+  VMLibraryHooks.packageRootUriFuture = _getPackageRootFuture;
+  VMLibraryHooks.packageConfigUriFuture = _getPackageConfigFuture;
+  VMLibraryHooks.resolvePackageUriFuture = _resolvePackageUriFuture;
 }