Display exports that lead to dart:mirrors.

pkg/compiler/lib/src/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 690 matching lines @@
   static int hashCodeCounter = 0;
 
 
   /**
    * A linked list of the import tags that import [library] mapped to the
    * corresponding libraries. This is used to propagate exports into imports
    * after the export scopes have been computed.
    */
   Link<ImportLink> imports = const Link<ImportLink>();
 
+  /// A linked list of all libraries directly exported by [library].
+  Link<LibraryElement> exports = const Link<LibraryElement>();
+
   /**
    * A linked list of the export tags the dependent upon this node library.
    * This is used to propagate exports during the computation of export scopes.
    */
   Link<ExportLink> dependencies = const Link<ExportLink>();
 
   /**
    * The export scope for [library] which is gradually computed by the work-list
    * computation in [LibraryDependencyHandler.computeExports].
    */
@@ skipping 22 matching lines @@
                                 LibraryElement importedLibrary) {
     imports = imports.prepend(new ImportLink(import, importedLibrary));
   }
 
   /**
    * Registers that the library of this node is exported by
    * [exportingLibraryNode] through the [export] tag.
    */
   void registerExportDependency(Export export,
                                 LibraryDependencyNode exportingLibraryNode) {
+    // Register the exported library in the exporting library node.
+    exportingLibraryNode.exports =
+        exportingLibraryNode.exports.prepend(library);
+    // Register the export in the exported library node.
     dependencies =
         dependencies.prepend(new ExportLink(export, exportingLibraryNode));
   }
 
   /**
    * Registers all non-private locally declared members of the library of this
    * node to be exported. This forms the basis for the work-list computation of
    * the export scopes performed in [LibraryDependencyHandler.computeExports].
    */
   void registerInitialExports() {
@@ skipping 334 matching lines @@
                          Link<Uri> prefix) {
       if (aborted) return;
 
       Uri canonicalUri = library.canonicalUri;
       prefix = prefix.prepend(canonicalUri);
       if (suffixChainMap.containsKey(library)) return;
       suffixChainMap[library] = const <Link<Uri>>[];
       List<Link<Uri>> suffixes = [];
       if (targetUri != canonicalUri) {
         LibraryDependencyNode node = nodeMap[library];
-        for (ImportLink import in node.imports.reverse()) {
+
+        /// Process the import (or export) of [importedLibrary].
+        void processLibrary(LibraryElement importedLibrary) {
           bool suffixesArePrecomputed =
-              suffixChainMap.containsKey(import.importedLibrary);
+              suffixChainMap.containsKey(importedLibrary);
 
           if (!suffixesArePrecomputed) {
-            computeSuffixes(import.importedLibrary, prefix);
+            computeSuffixes(importedLibrary, prefix);
             if (aborted) return;
           }
 
-          for (Link<Uri> suffix in suffixChainMap[import.importedLibrary]) {
+          for (Link<Uri> suffix in suffixChainMap[importedLibrary]) {
             suffixes.add(suffix.prepend(canonicalUri));
 
             if (suffixesArePrecomputed) {
               // Only report chains through [import] if the suffixes had already
               // been computed, otherwise [computeSuffixes] have reported the
               // paths through [prefix].
               Link<Uri> chain = prefix;
               while (!suffix.isEmpty) {
                 chain = chain.prepend(suffix.head);
                 suffix = suffix.tail;
               }
               if (!callback(chain)) {
                 aborted = true;
                 return;
               }
             }
           }
         }
+
+        for (ImportLink import in node.imports.reverse()) {
+          processLibrary(import.importedLibrary);
+          if (aborted) return;
+        }
+        for (LibraryElement exportedLibrary in node.exports.reverse()) {
+          processLibrary(exportedLibrary);
+          if (aborted) return;
+        }
       } else { // Here `targetUri == canonicalUri`.
         if (!callback(prefix)) {
           aborted = true;
           return;
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }