fix a few issues around exported libraries

lib/src/mirror_loader.dart

 // Copyright (c) 2015, 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 initialize.mirror_loader;
 
 import 'dart:collection' show Queue;
 import 'dart:mirrors';
 import 'package:path/path.dart' as path;
 import 'package:initialize/initialize.dart';
 
+final _root = currentMirrorSystem().isolate.rootLibrary;
+
 Queue<Function> loadInitializers(
     {List<Type> typeFilter, InitializerFilter customFilter}) {
   return new InitializationCrawler(typeFilter, customFilter).run();
 }
 
 // Crawls a library and all its dependencies for `Initializer` annotations using
 // mirrors
 class InitializationCrawler {
   // Set of all visited annotations, keys are the declarations that were
   // annotated, values are the annotations that have been processed.
   static final _annotationsFound =
       new Map<DeclarationMirror, Set<InstanceMirror>>();
 
   // If non-null, then only these annotations should be processed.
   final List<Type> typeFilter;
 
   // If non-null, then only annotations which return true when passed to this
   // function will be processed.
   final InitializerFilter customFilter;
 
-  // The root library that we start parsing from.
-  LibraryMirror _root;
-
-  InitializationCrawler(this.typeFilter, this.customFilter,
-      {LibraryMirror root}) {
-    _root = root == null ? currentMirrorSystem().isolate.rootLibrary : root;
-  }
+  InitializationCrawler(this.typeFilter, this.customFilter);
 
   // The primary function in this class, invoke it to crawl and collect all the
   // annotations into a queue of init functions.
-  Queue<Function> run() => _readLibraryDeclarations(_root);
+  Queue<Function> run() {
+    var librariesSeen = new Set<LibraryMirror>();
+    var queue = new Queue<Function>();
+
+    var libraries = currentMirrorSystem().libraries;
+    var nonDartOrPackageImports = new List.from(libraries.keys.where(
+        (uri) => uri.scheme != 'package' && uri.scheme != 'dart'));
+
+    for (var import in nonDartOrPackageImports.reversed) {
+      // Always load the package: version of a library if available.
+      var libToRun;
+      if (_isHttpStylePackageUrl(import)) {
+        var packageUri = _packageUriFor(import);
+        libToRun = libraries[packageUri];
+      }
+      if (libToRun == null) libToRun = libraries[import];
+
+      // Dartium creates an extra trampoline lib that loads the main dart script
+      // and breaks our ordering.
+      if (librariesSeen.contains(libToRun) ||
+          libToRun.uri.path.endsWith('\$trampoline')) {
+        continue;
+      }
+      _readLibraryDeclarations(libToRun, librariesSeen, queue);
+    }
+
+    return queue;
+  }
+
+  /// Whether [uri] is an http URI that contains a 'packages' segment, and
+  /// therefore could be converted into a 'package:' URI.
+  bool _isHttpStylePackageUrl(Uri uri) {
+    var uriPath = uri.path;
+    return uri.scheme == _root.uri.scheme &&
+        // Don't process cross-domain uris.
+        uri.authority == _root.uri.authority &&
+        uriPath.endsWith('.dart') &&
+        (uriPath.contains('/packages/') || uriPath.startsWith('packages/'));
+  }
+
+  Uri _packageUriFor(Uri httpUri) {
+    var packagePath = httpUri.path.substring(
+        httpUri.path.lastIndexOf('packages/') + 'packages/'.length);
+    return Uri.parse('package:$packagePath');
+  }
 
   // Reads Initializer annotations on this library and all its dependencies in
   // post-order.
   Queue<Function> _readLibraryDeclarations(LibraryMirror lib,
-      [Set<LibraryMirror> librariesSeen, Queue<Function> queue]) {
-    if (librariesSeen == null) librariesSeen = new Set<LibraryMirror>();
-    if (queue == null) queue = new Queue<Function>();
+      Set<LibraryMirror> librariesSeen, Queue<Function> queue) {
     librariesSeen.add(lib);
 
     // First visit all our dependencies.
     for (var dependency in _sortedLibraryDependencies(lib)) {
       // Skip dart: imports, they never use this package.
       if (dependency.targetLibrary.uri.toString().startsWith('dart:')) continue;
       if (librariesSeen.contains(dependency.targetLibrary)) continue;
 
       _readLibraryDeclarations(dependency.targetLibrary, librariesSeen, queue);
     }
@@ skipping 82 matching lines @@
         if (declaration.owner is! LibraryMirror) {
           // TODO(jakemac): Support static class methods.
           throw _TOP_LEVEL_FUNCTIONS_ONLY;
         }
         annotatedValue = (declaration.owner as ObjectMirror)
             .getField(declaration.simpleName).reflectee;
       } else if (declaration is LibraryMirror) {
         var package;
         var filePath;
         Uri uri = declaration.uri;
+        // Convert to a package style uri if possible.
+        if (_isHttpStylePackageUrl(uri)) {
+          uri = _packageUriFor(uri);
+        }
         if (uri.scheme == 'file' || uri.scheme.startsWith('http')) {
           filePath = path.url.relative(uri.path,
               from: path.url.dirname(_root.uri.path));
         } else if (uri.scheme == 'package') {
           var segments = uri.pathSegments;
           package = segments[0];
           filePath = path.url.joinAll(segments.getRange(1, segments.length));
         } else {
           throw new UnsupportedError('Unsupported uri scheme ${uri.scheme} for '
               'library ${declaration}.');
@@ skipping 24 matching lines @@
     return true;
   }
 }
 
 final _TOP_LEVEL_FUNCTIONS_ONLY = new UnsupportedError(
     'Only top level methods are supported for initializers');
 
 final _UNSUPPORTED_DECLARATION = new UnsupportedError(
     'Initializers are only supported on libraries, classes, and top level '
     'methods');