Emit warning on import of dart:mirrors.

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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 import 'dart2jslib.dart'
     show Compiler,
          CompilerTask,
@@ skipping 231 matching lines @@
   bool exclude(Element element) => excludedNames.contains(element.name);
 }
 
 /**
  * Implementation class for [LibraryLoader]. The distinction between
  * [LibraryLoader] and [LibraryLoaderTask] is made to hide internal members from
  * the [LibraryLoader] interface.
  */
 class _LibraryLoaderTask extends CompilerTask implements LibraryLoaderTask {
   _LibraryLoaderTask(Compiler compiler) : super(compiler);
+
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryCanonicalUriMap =
       new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
@@ skipping 73 matching lines @@
     return measure(() {
       assert(currentHandler == null);
       // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
       // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(this);
       return createLibrary(currentHandler, null, resolvedUri)
           .then((LibraryElement library) {
         return compiler.withCurrentElement(library, () {
           return measure(() {
             currentHandler.computeExports();
-            Map<Uri, LibraryElement> loadedLibraries = <Uri, LibraryElement>{};
-            currentHandler.loadedLibraries.forEach(
-                (LibraryElement loadedLibrary) {
-              loadedLibraries[loadedLibrary.canonicalUri] = loadedLibrary;
-            });
+            LoadedLibraries loadedLibraries =
+                new _LoadedLibraries(library, currentHandler.nodeMap);
             currentHandler = null;
             return compiler.onLibrariesLoaded(loadedLibraries)
                 .then((_) => library);
           });
         });
       });
     });
   }
 
   /**
@@ skipping 665 matching lines @@
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 
   Future processLibraryTags(LibraryElement library) {
     return task.processLibraryTags(this, library);
   }
 }
+
+/// Information on the bulk of newly loaded libraries through a call to
+/// [LibraryLoader.loadLibrary].
+abstract class LoadedLibraries {
+  /// The uri passed to [LibraryLoader.loadLibrary].
+  Uri get rootUri;
+
+  /// Returns `true` if a library with canonical [uri] was loaded in this bulk.
+  bool containsLibrary(Uri uri);
+
+  /// Returns the library with canonical [uri] that was loaded in this bulk.
+  LibraryElement getLibrary(Uri uri);
+
+  /// Applies all libraries in this bulk to [f].
+  void forEachLibrary(f(LibraryElement library));
+
+  /// Applies all library imports in this bulk to [f].
+  ///
+  /// The argument [importChainReversed] to [f] contains the chain of imports
+  /// uris that lead to importing [library] starting in the canonical uri for
+  /// [library] and ending in [rootUri].
+  ///
+  /// [f] is called once for each chain of imports leading to [library].
+  void forEachImportChain(f(LibraryElement library,
+                            Link<Uri> importChainReversed));
+}
+
+class _LoadedLibraries implements LoadedLibraries {
+  final LibraryElement rootLibrary;
+  final Map<Uri, LibraryElement> loadedLibraries = <Uri, LibraryElement>{};
+  final Map<LibraryElement, LibraryDependencyNode> nodeMap;
+
+  _LoadedLibraries(this.rootLibrary, this.nodeMap) {
+    nodeMap.keys.forEach((LibraryElement loadedLibrary) {
+      loadedLibraries[loadedLibrary.canonicalUri] = loadedLibrary;
+    });
+  }
+
+  Uri get rootUri => rootLibrary.canonicalUri;
+
+  bool containsLibrary(Uri uri) => loadedLibraries.containsKey(uri);
+
+  LibraryElement getLibrary(Uri uri) => loadedLibraries[uri];
+
+  void forEachLibrary(f(LibraryElement library)) => nodeMap.keys.forEach(f);
+
+  void forEachImportChain(f(LibraryElement library, Link<Uri> importChain)) {
+    processImports(rootLibrary, const Link<Uri>(), f);
+  }
+
+  void processImports(LibraryElement library,

[floitsch, 2014/09/22 20:52:59]

If the method is not in the public API I would make it private.

[Johnni Winther, 2014/11/12 13:06:26]

Done.

+                      Link<Uri> uris,
+                      f(LibraryElement library, Link<Uri> importChain)) {
+    Uri uri = library.canonicalUri;
+    if (uris.contains(uri)) {
+      // Cyclic import.
+      return;
+    }
+    uris = uris.prepend(uri);
+    f(library, uris);
+    LibraryDependencyNode node = nodeMap[library];
+    // TODO(johnniwinther): Reversing the imports every lookup.
+    for (ImportLink import in node.imports.reverse()) {
+      processImports(import.importedLibrary, uris, f);
+    }
+  }
+}