Try to reuse temporary 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 381 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;
+  final List<String> freeTemporaryNames;
   int temporaryIndex = 0;
 
   VariableNamer(LiveEnvironment environment, this.names, this.parameterNames)
-    : usedNames = new Set<String>() {
+    : usedNames = new Set<String>(),
+      freeTemporaryNames = new List<String>() {
     // [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(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() {
+    while (!freeTemporaryNames.isEmpty()) {
+      String name = freeTemporaryNames.removeLast();
+      if (!usedNames.contains(name)) return name;
+    }
     String name = 't${temporaryIndex++}';
     while (usedNames.contains(name)) name = 't${temporaryIndex++}';
     return name;
   }
 
   HPhi firstPhiUserWithElement(HInstruction instruction) {
     for (HInstruction user in instruction.usedBy) {
       if (user is HPhi && user.sourceElement !== null) {
         return user;
       }
@@ skipping 43 matching lines @@
     names.ownName[instruction] = name;
     return name;
   }
 
   /**
    * Frees [instruction]'s name so it can be used for other instructions.
    */
   void freeName(HInstruction instruction) {
     String ownName = names.ownName[instruction];
     if (ownName != null) {
+      RegExp regexp = const RegExp('t[0-9]+');
+      // We check if we have already looked for temporary names
+      // because if we haven't, chances are the temporary we allocate
+      // in this block can match a phi with the same name in the
+      // successor block.
+      if (temporaryIndex != 0 && regexp.hasMatch(ownName)) {
+        freeTemporaryNames.addLast(ownName);
+      }
       usedNames.remove(ownName);
     }
   }
 }
 
 /**
  * Visits all blocks in the graph, sets names to instructions, and
  * creates the [CopyHandler] for each block. This class needs to have
  * the liveIns set as well as all the live intervals of instructions.
  * It visits the graph in dominator order, so that at each entry of a
@@ skipping 94 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }