Changed LinkedHashSet to Set and LinkedHashMap to Map.

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.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 206 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';
   List onLibraryLoadedCallbacks = [];
 
   final Map<String, LibraryElement> libraryNames =
-      new LinkedHashMap<String, LibraryElement>();
+      new Map<String, LibraryElement>();
 
   LibraryDependencyHandler currentHandler;
 
   Future<LibraryElement> loadLibrary(Uri resolvedUri, Node node,
       Uri canonicalUri) {
     return measure(() {
       assert(currentHandler == null);
       // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
       // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(compiler);
@@ skipping 359 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 LinkedHashMap<SourceString, Element>();
+      new Map<SourceString, Element>();
 
   /// Map from exported elements to the export directives that exported them.
   Map<Element, Link<Export>> exporters = new Map<Element, Link<Export>>();
 
   /**
    * The set of exported elements that need to be propageted to dependent
    * libraries as part of the work-list computation performed in
    * [LibraryDependencyHandler.computeExports]. Each export element is mapped
    * to a list of exports directives that export it.
    */
@@ skipping 182 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 LinkedHashMap<LibraryElement,LibraryDependencyNode>();
+      new Map<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;
@@ skipping 77 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();
   }
 }