Compute the swap temporary to not clash with parameter names.

dart/lib/compiler/implementation/ssa/variable_allocator.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.
 
 /**
  * The [LiveRange] class covers a range where an instruction is live.
  */
 class LiveRange {
   final int start;
   // [end] is not final because it can be updated due to loops.
@@ skipping 330 matching lines @@
  * Contains the mapping between instructions and their names for code
  * generation, as well as the [CopyHandler] for each basic block.
  */
 class VariableNames {
   final Map<HInstruction, String> ownName;
   final Map<HBasicBlock, CopyHandler> copyHandlers;
   /**
    * Name that is being used as a temporary to break cycles in
    * parallel copies. We make sure this name is not being used
    * anywhere by reserving it when we allocate names for instructions.
-   * TODO(ngeoffray): This isn't true for parameters, and we should
-   * rename the parameter name, to keep it simple.
    */
-  static final String SWAP_TEMP = 't0';
+  final String swapTemp;
 
-  VariableNames()
+  VariableNames(Map<Element, String> parameterNames)
     : ownName = new Map<HInstruction, String>(),
-      copyHandlers = new Map<HBasicBlock, CopyHandler>();
+      copyHandlers = new Map<HBasicBlock, CopyHandler>(),
+      swapTemp = computeSwapTemp(parameterNames);
+
+  static String computeSwapTemp(Map<Element, String> parameterNames) {
+    Set<String> parameters = new Set<String>.from(parameterNames.getValues());

[Lasse Reichstein Nielsen, 2012/06/07 08:53:21]

Can't you use this.names somehow, since it's initialized with the parameter
names? I guess we don't want to conflict with any name, not just parameters.
That would also avoid having an extra field for parameterNames.

[ngeoffray, 2012/06/07 09:10:41]

As discussed, there is no extra field in this class. And parameterNames is used
by VariableNames and VariableNamer.

+    String name = 't0';
+    int i = 1;
+    while (parameters.contains(name)) name = 't${i++}';
+    return name;
+  }
 
   String getName(HInstruction instruction) {
     return ownName[instruction];
   }
 
   CopyHandler getCopyHandler(HBasicBlock block) {
     return copyHandlers[block];
   }
 
   bool hasName(HInstruction instruction) => ownName.containsKey(instruction);
@@ skipping 14 matching lines @@
 /**
  * Allocates variable names for instructions, making sure they don't collide.
  */
 class VariableNamer {
   final VariableNames names;
   final Set<String> usedNames;
   final Map<Element, String> parameterNames;
 
   VariableNamer(LiveEnvironment environment, this.names, this.parameterNames)
     : usedNames = new Set<String>() {
-    // [VariableNames.SWAP_TEMP] is being used when there is a cycle
+    // [VariableNames.swapTemp] is being used when there is a cycle
     // in a copy handler. Therefore we make sure no one will use it.
-    usedNames.add(VariableNames.SWAP_TEMP);
+    usedNames.add(names.swapTemp);
 
     // All liveIns instructions must have a name at this point, so we
     // add them to the list of used names.
     environment.liveInstructions.forEach((HInstruction instruction, int index) {
       String name = names.getName(instruction);
       if (name !== null) {
         usedNames.add(name);
       }
     });
   }
 
   String allocateWithHint(String originalName) {
     int i = 0;
     String name = JsNames.getValid(originalName);
     while (usedNames.contains(name)) {
       name = JsNames.getValid('$originalName${i++}');
     }
     return name;
   }
 
   String allocateTemporary() {
-    // Don't start at 0 because t0 is being used for
-    // [VariableNames.SWAP_TEMP].
-    int i = 1;
+    int i = 0;
     String name = 't${i++}';
     while (usedNames.contains(name)) name = 't${i++}';

[Lasse Reichstein Nielsen, 2012/06/07 08:53:21]

This looks like something that has quadratic performance in the number of
allocated temporaries. How about storing i between calls?

[ngeoffray, 2012/06/07 09:10:41]

Good point. Done.

     return name;
   }
 
   HPhi firstPhiUserWithElement(HInstruction instruction) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi && user.sourceElement !== null) {
         return user;
       }
     }
     return null;
@@ skipping 64 matching lines @@
   final Map<HInstruction, LiveInterval> liveIntervals;
   final Set<HInstruction> generateAtUseSite;
   final Map<Element, String> parameterNames;
 
   final VariableNames names;
 
   SsaVariableAllocator(this.compiler,
                        this.liveInstructions,
                        this.liveIntervals,
                        this.generateAtUseSite,
-                       this.parameterNames)
-    : names = new VariableNames();
+                       parameterNames)
+    : this.names = new VariableNames(parameterNames),
+      this.parameterNames = parameterNames;
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     VariableNamer namer = new VariableNamer(
         liveInstructions[block], names, parameterNames);
 
     block.forEachPhi((HPhi phi) {
@@ skipping 53 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }