Fixes for checked mode and change buildbot script to run dart2js tests in checked mode also.

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 97 matching lines @@
 
   /**
    * Remove an instruction from the liveIn set. This method also
    * updates the live interval of [instruction] to contain the new
    * range: [id, / id contained in [liveInstructions] /].
    */
   void remove(HInstruction instruction, int id) {
     // Special case the HCheck instruction to have the same live
     // interval as the instruction it is checking.
     if (instruction is HCheck) {
-      HInstruction input = instruction.checkedInput;
+      var input = instruction.checkedInput;
       while (input is HCheck) input = input.checkedInput;
       liveIntervals.putIfAbsent(input, () => new LiveInterval());
       liveIntervals.putIfAbsent(instruction, () => liveIntervals[input]);
-      return;
+    } else {
+      LiveInterval range = liveIntervals.putIfAbsent(
+          instruction, () => new LiveInterval());
+      int lastId = liveInstructions[instruction];
+      // If [lastId] is null, then this instruction is not being used.
+      range.add(new LiveRange(id, lastId == null ? id : lastId));
+      // The instruction is defined at [id].
+      range.start = id;
     }
-    LiveInterval range = liveIntervals.putIfAbsent(
-        instruction, () => new LiveInterval());
-    int lastId = liveInstructions[instruction];
-    // If [lastId] is null, then this instruction is not being used.
-    range.add(new LiveRange(id, lastId == null ? id : lastId));
-    // The instruction is defined at [id].
-    range.start = id;
     liveInstructions.remove(instruction);
   }
 
   /**
    * Add [instruction] to the liveIn set. If the instruction is not
    * already in the set, we save the id where it dies.
    */
   void add(HInstruction instruction, int userId) {
-    // Special case the HCheck instruction to use the actual checked
-    // instruction.
-    while (instruction is HCheck) instruction = instruction.checkedInput;
     // Note that we are visiting the grap in post-dominator order, so
     // the first time we see a variable is when it dies.
     liveInstructions.putIfAbsent(instruction, () => userId);
+    if (instruction is HCheck) {
+      // Special case the HCheck instruction to mark the actual
+      // checked instruction live.
+      liveInstructions.putIfAbsent(instruction, () => userId);
+      var input = instruction.checkedInput;
+      while (input is HCheck) input = input.checkedInput;
+      liveInstructions.putIfAbsent(input, () => userId);
+    }
   }
 
   /**
    * Merge this environment with [other]. Update the end id of
    * instructions in case they are different between this and [other].
    */
   void mergeWith(LiveEnvironment other) {
     other.liveInstructions.forEach((HInstruction instruction, int existingId) {
       // If both environments have the same instruction id of where
       // [instruction] dies, there is no need to update the live
@@ skipping 272 matching lines @@
       if (user is HPhi && user.sourceElement !== null) {
         return user;
       }
     }
     return null;
   }
 
   String allocateName(HInstruction instruction) {
     String name;
     if (instruction is HCheck) {
-      // Special case the check instruction to use the name of its
-      // checked instruction.
-      HCheck check = instruction;
-      name = names.ownName[check.checkedInput];
-      // If the name is null, then the checked input is being
-      // generated at use site, and we don't need a name for the check
-      // instruction.
-      if (name == null) return null;
+      // Special case this instruction to use the name of its
+      // input if it has one.
+      var temp = instruction;
+      do {
+        temp = temp.checkedInput;
+        name = names.ownName[temp];
+      } while (name == null && temp is HCheck);
+      if (name !== null) return addAllocatedName(instruction, name);
     } else if (instruction is HParameterValue) {
       HParameterValue parameter = instruction;
       name = parameterNames[parameter.sourceElement];
       if (name == null) {
         name = allocateWithHint(parameter.sourceElement.name.slowToString());
       }
-    } else if (instruction.sourceElement !== null) {
+      return addAllocatedName(instruction, name);
+    }
+
+    if (instruction.sourceElement !== null) {
       name = allocateWithHint(instruction.sourceElement.name.slowToString());
     } else {
       // We could not find an element for the instruction. If the
       // instruction is used by a phi, try to use the name of the phi.
       // Otherwise, just allocate a temporary name.
       HPhi phi = firstPhiUserWithElement(instruction);
       if (phi !== null) {
         name = allocateWithHint(phi.sourceElement.name.slowToString());
       } else {
         name = allocateTemporary();
       }
     }
+
+    return addAllocatedName(instruction, name);
+  }
+
+  String addAllocatedName(HInstruction instruction, String name) {
     usedNames.add(name);
     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];
@@ skipping 53 matching lines @@
    * Returns whether [instruction] needs a name. Instructions that
    * have no users or that are generated at use site does not need a name.
    */
   bool needsName(HInstruction instruction) {
     if (instruction.usedBy.isEmpty()) return false;
     // TODO(ngeoffray): parameters are being generated at use site,
     // but we need a name for parameters. We should probably not make
     // them generate at use site to make things simpler.
     if (instruction is HParameterValue && instruction is !HThis) return true;
     if (generateAtUseSite.contains(instruction)) return false;
+    // A [HCheck] instruction that has control flow needs a name only if its
+    // checked input needs a name (e.g. a check [HConstant] does not
+    // need a name).
+    if (instruction is HCheck && instruction.isControlFlow()) {
+      HCheck check = instruction;
+      return needsName(instruction.checkedInput);
+    }
     return true;
   }
  
   /**
    * Returns whether [instruction] dies at the instruction [at].
    */
   bool diesAt(HInstruction instruction, HInstruction at) {
     LiveInterval atInterval = liveIntervals[at];
     LiveInterval instructionInterval = liveIntervals[instruction];
     int start = atInterval.start;
@@ skipping 24 matching lines @@
       if (!needsName(input)) {
         names.addAssignment(predecessor, input, phi);
       } else {
         names.addCopy(predecessor, input, phi);
       }
     }
 
     namer.allocateName(phi);
   }
 }