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

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 523 matching lines @@
           var operation = instruction.operation.name;
           declareInstruction(instruction);
           buffer.add(' ${operation}= ${value}');
         }
         return true;
       }
     }
     return false;
   }
 
+  // For simple type checks like i = intTypeCheck(i), we don't have to
+  // emit an assignment, because the intTypeCheck just returns its
+  // argument.
+  bool handleTypeConversion(instruction, name) {
+    if (instruction is !HTypeConversion) return false;
+    String inputName = variableNames.getName(instruction.checkedInput);
+    if (name != inputName) return false;
+    visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
+    return true;
+  }
+
   void define(HInstruction instruction) {
     if (isGeneratingExpression()) {
       addExpressionSeparator();
     } else {
       addIndentation();
     }
-    if (instruction is !HCheck && variableNames.hasName(instruction)) {
+    if (!instruction.isControlFlow() && variableNames.hasName(instruction)) {
       var name = variableNames.getName(instruction);
-      if (!handleSimpleUpdateDefinition(instruction, name)) {
+      if (!handleSimpleUpdateDefinition(instruction, name)
+          && !handleTypeConversion(instruction, name)) {
         declareInstruction(instruction);
         buffer.add(" = ");
         visit(instruction, JSPrecedence.ASSIGNMENT_PRECEDENCE);
       }
     } else {
       visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
     }
     if (!isGeneratingExpression()) buffer.add(';\n');
   }
 
   void use(HInstruction argument, int expectedPrecedenceForArgument) {
     if (isGenerateAtUseSite(argument)) {
       visit(argument, expectedPrecedenceForArgument);
-    } else if (argument is HCheck) {
+    } else if (argument is HCheck && argument.isControlFlow()) {
+      // A [HCheck] that has control flow can never be used as an
+      // expression and may not have a name. Therefore we just use the
+      // checked instruction.
       HCheck check = argument;
-      use(argument.checkedInput, expectedPrecedenceForArgument);
+      use(check.checkedInput, expectedPrecedenceForArgument);
     } else {
       buffer.add(variableNames.getName(argument));
     }
   }
 
   visit(HInstruction node, int expectedPrecedenceForNode) {
     int oldPrecedence = this.expectedPrecedence;
     this.expectedPrecedence = expectedPrecedenceForNode;
     node.accept(this);
     this.expectedPrecedence = oldPrecedence;
@@ skipping 1911 matching lines @@
   }
 
   void endGraph(HGraph graph) {
     if (!graph.entry.hasGuards()) return;
     indent--; // Close original case.
     indent--;
     addIndented('}\n');  // Close 'switch'.
     setup.add('  }\n');
   }
 
-  // For instructions that reference a guard or a check, we change that
-  // reference to the instruction they guard against. Therefore, we must
-  // use that instruction when restoring the environment.
-  HInstruction unwrap(argument) {
-    while (argument is HCheck) argument = argument.checkedInput;
-    return argument;
-  }
-
   bool visitAndOrInfo(HAndOrBlockInformation info) => false;
   bool visitIfInfo(HIfBlockInformation info) => false;
   bool visitLoopInfo(HLoopBlockInformation info) => false;
   bool visitTryInfo(HTryBlockInformation info) => false;
   bool visitSequenceInfo(HStatementSequenceInformation info) => false;
 
   void visitTypeGuard(HTypeGuard node) {
     indent--;
     addIndented('case ${node.state}:\n');
     indent++;
     addIndented('state = 0;\n');
 
     setup.add('    case ${node.state}:\n');
     int i = 0;
     for (HInstruction input in node.inputs) {
-      HInstruction instruction = unwrap(input);
-      setup.add('      ${variableNames.getName(instruction)} = env$i;\n');
+      setup.add('      ${variableNames.getName(input)} = env$i;\n');
       i++;
     }
     if (i > maxBailoutParameters) maxBailoutParameters = i;
     setup.add('      break;\n');
   }
 
   void startBailoutCase(List<HTypeGuard> bailouts1,
                         List<HTypeGuard> bailouts2) {
     indent--;
     handleBailoutCase(bailouts1);
@@ skipping 138 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }