- Add --trace-loading to trace resolution and loading.

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:isolate';
 import 'dart:typed_data';
 
-// import 'root_library'; happens here from C Code
-
-// Build time flag to enable debug logging of loading code.
-const _logLoading = false;
-
-
 // The root library (aka the script) is imported into this library. The
 // standalone embedder uses this to lookup the main entrypoint in the
 // root library's namespace.
 Function _getMainClosure() => main;
 
 
 // 'print' implementation.
 // The standalone embedder registers the closurized _print function with the
 // dart:core library.
 void _printString(String s) native "Builtin_PrintString";
@@ skipping 26 matching lines @@
 
 // Asynchronous loading of resources.
 // The embedder forwards most loading requests to this library.
 
 // See Dart_LibraryTag in dart_api.h
 const Dart_kScriptTag = null;
 const Dart_kImportTag = 0;
 const Dart_kSourceTag = 1;
 const Dart_kCanonicalizeUrl = 2;
 
+// Embedder sets this to true if the --trace-loading flag was passed on the
+// command line.
+bool _traceLoading = false;
+
 // A port for communicating with the service isolate for I/O.
 SendPort _loadPort;
 // Maintain a number of outstanding load requests. Current loading request is
 // finished once there are no outstanding requests.
 int _numOutstandingLoadRequests = 0;
 
 // The current working directory when the embedder was launched.
-var _workingDirectoryUri;
-// The URI that the entry point script was loaded from. Remembered so that
-// package imports can be resolved relative to it.
-var _entryPointScript;
+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;
 // The directory to look in to resolve "package:" scheme URIs. By detault it is
 // the 'packages' directory right next to the script.
-var _packageRoot = _entryPointScript.resolve('packages/');
+Uri _packageRoot = _rootScript.resolve('packages/');
 
 // Special handling for Windows paths so that they are compatible with URI
 // handling.
-// Embedder sets whether we are running on Windows.
-var _isWindows;
+// Embedder sets this to true if we are running on Windows.
+bool _isWindows = false;
 
 
 // A class wrapping the load error message in an Error object.
 class LoadError extends Error {
   final String message;
   LoadError(this.message);
 
   String toString() => 'Load Error: $message';
 }
 
@@ skipping 54 matching lines @@
   if (!uri.endsWith('/')) {
     return '$uri/';
   }
   return uri;
 }
 
 
 // Embedder Entrypoint:
 // The embedder calls this method with the current working directory.
 void _setWorkingDirectory(cwd) {
-  if (_logLoading) {
+  if (_traceLoading) {
     _print('# Setting working directory: $cwd');
   }
-  _workingDirectoryUri = new Uri.directory(cwd);
-  if (_logLoading) {
-    _print('# Working directory URI: $_workingDirectoryUri');
+  _workingDirectory = new Uri.directory(cwd);
+  if (_traceLoading) {
+    _print('# Working directory URI: $_workingDirectory');
   }
 }
 
 
 // Embedder Entrypoint:
 // The embedder calls this method with a custom package root.
 _setPackageRoot(String packageRoot) {
+  if (_traceLoading) {
+    _print('# Setting package root: $packageRoot');
+  }
   packageRoot = _enforceTrailingSlash(packageRoot);
   if (packageRoot.startsWith('file:') ||
       packageRoot.startsWith('http:') ||
       packageRoot.startsWith('https:')) {
-    _packageRoot = _workingDirectoryUri.resolve(packageRoot);
+    _packageRoot = _workingDirectory.resolve(packageRoot);
   } else {
     packageRoot = _sanitizeWindowsPath(packageRoot);
     packageRoot = _trimWindowsPath(packageRoot);
-    _packageRoot = _workingDirectoryUri.resolveUri(new Uri.file(packageRoot));
+    _packageRoot = _workingDirectory.resolveUri(new Uri.file(packageRoot));
   }
-  if (_logLoading) {
-    _print('# Package root: $packageRoot -> $_packageRoot');
+  if (_traceLoading) {
+    _print('# 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) {
   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 (_logLoading) {
+  if (_traceLoading) {
     _print('# Package root: $_packageRoot');
     _print('# uri path: ${uri.path}');
   }
   return _packageRoot.resolve(uri.path);
 }
 
 
 // Resolves the script uri in the current working directory iff the given uri
 // did not specify a scheme (e.g. a path to a script file on the command line).
 Uri _resolveScriptUri(String scriptName) {
-  if (_workingDirectoryUri == null) {
+  if (_workingDirectory == null) {
     throw 'No current working directory set.';
   }
   scriptName = _sanitizeWindowsPath(scriptName);
 
   var scriptUri = Uri.parse(scriptName);
   if (scriptUri.scheme == '') {
     // Script does not have a scheme, assume that it is a path,
     // resolve it against the working directory.
-    scriptUri = _workingDirectoryUri.resolveUri(scriptUri);
+    scriptUri = _workingDirectory.resolveUri(scriptUri);
   }
 
-  // Remember the entry point script URI so that we can resolve packages
-  // based on this location.
-  _entryPointScript = scriptUri;
+  // Remember the root script URI so that we can resolve packages based on
+  // this location.
+  _rootScript = scriptUri;
 
-  if (_logLoading) {
-    _print('# Resolved entry point to: $_entryPointScript');
+  if (_traceLoading) {
+    _print('# Resolved entry point to: $_rootScript');
   }
   return scriptUri;
 }
 
 
 void _finishLoadRequest(String uri) {
   assert(_numOutstandingLoadRequests > 0);
   _numOutstandingLoadRequests--;
-  if (_logLoading) {
+  if (_traceLoading) {
     _print("Loading of $uri finished, "
            "${_numOutstandingLoadRequests} requests remaining");
   }
   if (_numOutstandingLoadRequests == 0) {
     _signalDoneLoading();
   }
 }
 
 
 void _startLoadRequest(String uri, Uri resourceUri) {
   assert(_numOutstandingLoadRequests >= 0);
   _numOutstandingLoadRequests++;
-  if (_logLoading) {
+  if (_traceLoading) {
     _print("Loading of $resourceUri for $uri started, "
            "${_numOutstandingLoadRequests} requests outstanding");
   }
 }
 
 
 void _loadScript(int tag, String uri, String libraryUri, Uint8List data) {
   // TODO: Currently a compilation error while loading the script is
   // fatal for the isolate. _loadScriptCallback() does not return and
   // the _numOutstandingLoadRequests counter remains out of sync.
   _loadScriptCallback(tag, uri, libraryUri, data);
   _finishLoadRequest(uri);
 }
 
 
 void _asyncLoadError(int tag, String uri, String libraryUri, LoadError error) {
-  if (_logLoading) {
+  if (_traceLoading) {
     _print("_asyncLoadError($uri), error: $error");
   }
   if (tag == Dart_kImportTag) {
     // When importing a library, the libraryUri is the imported
     // uri.
     libraryUri = uri;
   }
   _asyncLoadErrorCallback(uri, libraryUri, error);
   _finishLoadRequest(uri);
 }
@@ skipping 19 matching lines @@
     // seen LoadError.
     var error = (e is LoadError) ? e : new LoadError(e.toString);
     _asyncLoadError(tag, uri, libraryUri, error);
   });
 
   try {
     var msg = [receivePort.sendPort, resourceUri.toString()];
     _loadPort.send(msg);
     _startLoadRequest(uri, resourceUri);
   } catch (e) {
-    if (_logLoading) {
+    if (_traceLoading) {
       _print("Exception when communicating with service isolate: $e");
     }
     // Wrap inside a LoadError unless we are already propagating a previously
     // seen LoadError.
     var error = (e is LoadError) ? e : new LoadError(e.toString);
     _asyncLoadError(tag, uri, libraryUri, error);
     receivePort.close();
   }
 }
 
@@ skipping 15 matching lines @@
   }
 
   _loadDataFromLoadPort(tag, uri, libraryUri, resourceUri);
 }
 
 
 // Embedder Entrypoint:
 // Function called by standalone embedder to resolve uris when the VM requests
 // Dart_kCanonicalizeUrl from the tag handler.
 String _resolveUri(String base, String userString) {
-  if (_logLoading) {
+  if (_traceLoading) {
     _print('# Resolving: $userString from $base');
   }
   var baseUri = Uri.parse(base);
   var result;
   if (userString.startsWith(_DART_EXT)) {
     var uri = userString.substring(_DART_EXT.length);
     result = '$_DART_EXT${baseUri.resolve(uri)}';
   } else {
     result = baseUri.resolve(userString).toString();
   }
-  if (_logLoading) {
+  if (_traceLoading) {
     _print('Resolved $userString in $base to $result');
   }
   return result;
 }
 
 
 // Embedder Entrypoint (gen_snapshot):
 // Resolve relative paths relative to working directory.
 String _resolveInWorkingDirectory(String fileName) {
-  if (_workingDirectoryUri == null) {
+  if (_workingDirectory == null) {
     throw 'No current working directory set.';
   }
   var name = _sanitizeWindowsPath(fileName);
 
   var uri = Uri.parse(name);
   if (uri.scheme != '') {
     throw 'Schemes are not supported when resolving filenames.';
   }
-  uri = _workingDirectoryUri.resolveUri(uri);
+  uri = _workingDirectory.resolveUri(uri);
 
-  if (_logLoading) {
+  if (_traceLoading) {
     _print('# Resolved in working directory: $fileName -> $uri');
   }
   return uri.toString();
 }
 
 
 // Handling of dart-ext loading.
 // Dart native extension scheme.
 const _DART_EXT = 'dart-ext:';
 
 String _nativeLibraryExtension() native "Builtin_NativeLibraryExtension";
 
 
 String _platformExtensionFileName(String name) {
   var extension = _nativeLibraryExtension();
 
   if (_isWindows) {
     return '$name.$extension';
   } else {
     return 'lib$name.$extension';
   }
 }
 
 
 // Returns either a file path or a URI starting with http[s]:, as a String.
 String _filePathFromUri(String userUri) {
   var uri = Uri.parse(userUri);
-  if (_logLoading) {
+  if (_traceLoading) {
     _print('# Getting file path from: $uri');
   }
 
   var path;
   switch (uri.scheme) {
     case '':
     case 'file':
     return uri.toFilePath();
     case 'package':
     return _filePathFromUri(_resolvePackageUri(uri).toString());
     case 'data':
     case 'http':
     case 'https':
     return uri.toString();
     default:
     // Only handling file, http, and package URIs
     // in standalone binary.
-    if (_logLoading) {
+    if (_traceLoading) {
       _print('# Unknown scheme (${uri.scheme}) in $uri.');
     }
     throw 'Not a known scheme: $uri';
   }
 }
 
 
 // Embedder Entrypoint:
 // When loading an extension the embedder calls this method to get the
 // different components.
@@ skipping 23 matching lines @@
   } else {
     name = userUri.substring(index + 1);
     path = userUri.substring(0, index + 1);
   }
 
   path = _filePathFromUri(path);
   var filename = _platformExtensionFileName(name);
 
   return [path, filename, name];
 }