Fix a bug which caused exported elements to conflict with locally defined ones.

dart/lib/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.
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  */
 abstract class LibraryLoader extends CompilerTask {
   LibraryLoader(Compiler compiler) : super(compiler);
 
@@ skipping 109 matching lines @@
 /**
  * Implementation class for [LibraryLoader]. The distinction between
  * [LibraryLoader] and [LibraryLoaderTask] is made to hide internal members from
  * the [LibraryLoader] interface.
  */
 class LibraryLoaderTask extends LibraryLoader {
   LibraryLoaderTask(Compiler compiler) : super(compiler);
   String get name => 'LibraryLoader';
 
   final Map<String, LibraryElement> libraryNames =
-      new Map<String, LibraryElement>();
+      new LinkedHashMap<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
   LibraryElement loadLibrary(Uri uri, Node node, Uri canonicalUri) {
     return measure(() {
       assert(currentHandler == null);
       currentHandler = new LibraryDependencyHandler(compiler);
       LibraryElement library =
           createLibrary(currentHandler, uri, node, canonicalUri);
       currentHandler.computeExports();
@@ skipping 315 matching lines @@
   /**
    * 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].
    */
-  Map<SourceString, Element> exportScope = new Map<SourceString, Element>();
+  Map<SourceString, Element> exportScope =
+      new LinkedHashMap<SourceString, Element>();
 
   /**
    * The set of exported elements that need to be propageted to dependent
    * libraries as part of the work-list computation performed in
    * [LibraryDependencyHandler.computeExports].
    */
   Set<Element> pendingExportSet = new Set<Element>();
 
   LibraryDependencyNode(LibraryElement this.library);
 
@@ skipping 116 matching lines @@
 class LibraryDependencyHandler {
   final Compiler compiler;
 
   /**
    * Newly loaded libraries and their corresponding node in the library
    * dependency graph. Libraries that have already been fully loaded are not
    * part of the dependency graph of this handler since their export scopes have
    * already been computed.
    */
   Map<LibraryElement,LibraryDependencyNode> nodeMap =
-      new Map<LibraryElement,LibraryDependencyNode>();
+      new LinkedHashMap<LibraryElement,LibraryDependencyNode>();
 
   LibraryDependencyHandler(Compiler this.compiler);
 
   /**
    * Performs a fixed-point computation on the export scopes of all registered
    * libraries and creates the import/export of the libraries based on the
    * fixed-point.
    */
   void computeExports() {
     bool changed = true;
     while (changed) {
       changed = false;
+      Map<LibraryDependencyNode, List<Element>> tasks =
+          new LinkedHashMap<LibraryDependencyNode, List<Element>>();
+
+      // Locally defined elements take precedence over exported
+      // elements.  So we must propagate local elements first.  We
+      // ensure this by pulling the pending exports before
+      // propagating.  This enforces that we handle exports
+      // breadth-first, with locally defined elements being level 0.
       nodeMap.forEach((_, LibraryDependencyNode node) {
-        var pendingExports = node.pullPendingExports();
+        List<Element> pendingExports = node.pullPendingExports();
+        tasks[node] = pendingExports;
+      });
+      tasks.forEach((LibraryDependencyNode node, List<Element> pendingExports) {
         pendingExports.forEach((Element element) {
           element = node.addElementToExportScope(compiler, element);
           if (node.propagateElement(element)) {
             changed = true;
           }
         });
       });
     }
 
     // Setup export scopes. These have to be set before computing the import
@@ skipping 45 matching lines @@
   }
 
   /**
    * 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();
   }
 }