Process handled exports correctly.

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.
 
 part of dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  */
 abstract class LibraryLoader extends CompilerTask {
@@ skipping 512 matching lines @@
    */
   void registerInitialExports() {
     pendingExportSet.addAll(
         library.localScope.values.filter((Element element) {
           // At this point [localScope] only contains members so we don't need
           // to check for foreign or prefix elements.
           return !element.name.isPrivate();
         }));
   }
 
+  void registerHandledExports(LibraryElement exportedLibraryElement,
+                              CombinatorFilter filter) {
+    assert(invariant(library, exportedLibraryElement.exportsHandled));

[ahe, 2013/01/04 08:46:35]

This invariant is not using the correct location. It should be the value of
exportNode where registerHandledExports is called. However, that's probably also
broken as the compiler doesn't have a current element at this point.

I'm not really sure what this means.

+    for (Element exportedElement in exportedLibraryElement.exports) {
+      if (!filter.exclude(exportedElement)) {
+        pendingExportSet.add(exportedElement);
+      }
+    }
+  }
+
   /**
    * Registers the compute export scope with the node library.
    */
   void registerExports() {
     library.setExports(exportScope.values);
   }
 
   /**
    * Registers the imports of the node library.
    */
@@ skipping 137 matching lines @@
   }
 
   /**
    * Registers that [library] depends on [loadedLibrary] through [tag].
    */
   void registerDependency(LibraryElement library,
                           LibraryDependency tag,
                           LibraryElement loadedLibrary) {
     if (tag is Export) {
       // [loadedLibrary] is exported by [library].
+      LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
+        var combinatorFilter = new CombinatorFilter.fromTag(tag);
+        exportingNode.registerHandledExports(loadedLibrary, combinatorFilter);
         return;
       }
       LibraryDependencyNode exportedNode = nodeMap[loadedLibrary];
-      LibraryDependencyNode exportingNode = nodeMap[library];
       assert(invariant(loadedLibrary, exportedNode != null,
           message: "$loadedLibrary has not been registered"));
       assert(invariant(library, exportingNode != null,
           message: "$library has not been registered"));
       exportedNode.registerExportDependency(tag, exportingNode);
     } else if (tag == null || tag is Import) {
       // [loadedLibrary] is imported by [library].
       LibraryDependencyNode importingNode = nodeMap[library];
       assert(invariant(library, importingNode != null,
           message: "$library has not been registered"));
       importingNode.registerImportDependency(tag, loadedLibrary);
     }
   }
 
   /**
    * Registers [library] for the processing of its import/export scope.
    */
   void registerNewLibrary(LibraryElement library) {
     nodeMap[library] = new LibraryDependencyNode(library);
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }