Changed LinkedHashSet to Set and LinkedHashMap to Map.

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 83 matching lines @@
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
   /**
    * The values of locals that can be directly accessed (without redirections
    * to boxes or closure-fields).
    *
-   * [directLocals] is iterated, so it is a [LinkedHashMap] to make the
+   * [directLocals] is iterated, so it is "insertion ordered" to make the
    * iteration order a function only of insertions and not a function of
    * e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
    * don't have source locations for [Elements.compareByPosition].
    */
-  LinkedHashMap<Element, HInstruction> directLocals;
+  Map<Element, HInstruction> directLocals;
   Map<Element, Element> redirectionMapping;
   SsaBuilder builder;
   ClosureClassMap closureData;
 
   LocalsHandler(this.builder)
-      : directLocals = new LinkedHashMap<Element, HInstruction>(),
+      : directLocals = new Map<Element, HInstruction>(),
         redirectionMapping = new Map<Element, Element>();
 
   get typesTask => builder.compiler.typesTask;
 
   /**
    * Creates a new [LocalsHandler] based on [other]. We only need to
    * copy the [directLocals], since the other fields can be shared
    * throughout the AST visit.
    */
   LocalsHandler.from(LocalsHandler other)
-      : directLocals =
-            new LinkedHashMap<Element, HInstruction>.from(other.directLocals),
+      : directLocals = new Map<Element, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         builder = other.builder,
         closureData = other.closureData;
 
   /**
    * Redirects accesses from element [from] to element [to]. The [to] element
    * must be a boxed variable or a variable that is stored in a closure-field.
    */
   void redirectElement(Element from, Element to) {
     assert(redirectionMapping[from] == null);
@@ skipping 359 matching lines @@
     }
   }
 
   /**
    * Create phis at the loop entry for local variables (ready for the values
    * from the back edge).  Populate the phis with the current values.
    */
   void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
     Map<Element, HInstruction> savedDirectLocals =
-        new LinkedHashMap<Element, HInstruction>.from(directLocals);
+        new Map<Element, HInstruction>.from(directLocals);
 
     // Create phis for all elements in the definitions environment.
     savedDirectLocals.forEach((Element element, HInstruction instruction) {
       if (isAccessedDirectly(element)) {
         // We know 'this' cannot be modified.
         if (!identical(element, closureData.thisElement)) {
           HPhi phi = new HPhi.singleInput(element, instruction);
           loopEntry.addPhi(phi);
           directLocals[element] = phi;
         } else {
@@ skipping 47 matching lines @@
    * If a phi node is necessary, it will use this handler's instruction as the
    * first input, and the otherLocals instruction as the second.
    */
   void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) {
     // If an element is in one map but not the other we can safely
     // ignore it. It means that a variable was declared in the
     // block. Since variable declarations are scoped the declared
     // variable cannot be alive outside the block. Note: this is only
     // true for nodes where we do joins.
     Map<Element, HInstruction> joinedLocals =
-        new LinkedHashMap<Element, HInstruction>();
+        new Map<Element, HInstruction>();
     otherLocals.directLocals.forEach((element, instruction) {
       // We know 'this' cannot be modified.
       if (identical(element, closureData.thisElement)) {
         assert(directLocals[element] == instruction);
         joinedLocals[element] = instruction;
       } else {
         HInstruction mine = directLocals[element];
         if (mine == null) return;
         if (identical(instruction, mine)) {
           joinedLocals[element] = instruction;
@@ skipping 13 matching lines @@
    * localsHandlers into a new one using phis.  The new localsHandler is
    * returned.  Unless it is also in the list, the current localsHandler is not
    * used for its values, only for its declared variables. This is a way to
    * exclude local values from the result when they are no longer in scope.
    */
   LocalsHandler mergeMultiple(List<LocalsHandler> localsHandlers,
                               HBasicBlock joinBlock) {
     assert(localsHandlers.length > 0);
     if (localsHandlers.length == 1) return localsHandlers[0];
     Map<Element, HInstruction> joinedLocals =
-        new LinkedHashMap<Element,HInstruction>();
+        new Map<Element,HInstruction>();
     HInstruction thisValue = null;
     directLocals.forEach((Element element, HInstruction instruction) {
       if (element != closureData.thisElement) {
         HPhi phi = new HPhi.noInputs(element);
         joinedLocals[element] = phi;
         joinBlock.addPhi(phi);
       } else {
         // We know that "this" never changes, if it's there.
         // Save it for later. While merging, there is no phi for "this",
         // so we don't have to special case it in the merge loop.
         thisValue = instruction;
       }
     });
     for (LocalsHandler handler in localsHandlers) {
       handler.directLocals.forEach((Element element, HInstruction instruction) {
         HPhi phi = joinedLocals[element];
         if (phi != null) {
           phi.addInput(instruction);
         }
       });
     }
     if (thisValue != null) {
       // If there was a "this" for the scope, add it to the new locals.
       joinedLocals[closureData.thisElement] = thisValue;
     }
 
     // Remove locals that are not in all handlers.
-    directLocals = new LinkedHashMap<Element, HInstruction>();
+    directLocals = new Map<Element, HInstruction>();
     joinedLocals.forEach((element, instruction) {
       if (instruction is HPhi
           && instruction.inputs.length != localsHandlers.length) {
         joinBlock.removePhi(instruction);
       } else {
         directLocals[element] = instruction;
       }
     });
     return this;
   }
@@ skipping 4971 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }