Remove cancel and make crash exit with code 253.

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 882 matching lines @@
             updateBody.statements.add(new js.Continue(null));
             body.statements.add(
                 new js.If(jsCondition, updateBody, new js.Break(null)));
             jsCondition = newLiteralBool(true);
           }
           loop = new js.Do(unwrapStatement(body), jsCondition);
         }
         currentContainer = oldContainer;
         break;
       default:
-        compiler.internalError(
-          'Unexpected loop kind: ${info.kind}',
-          instruction: condition.conditionExpression);
+        compiler.internalError(condition.conditionExpression,
+            'Unexpected loop kind: ${info.kind}.');
     }
     attachLocationRange(loop, info.sourcePosition, info.endSourcePosition);
     js.Statement result = loop;
     if (info.kind == HLoopBlockInformation.SWITCH_CONTINUE_LOOP) {
       String continueLabelString =
           backend.namer.implicitContinueLabelName(info.target);
       result = new js.LabeledStatement(continueLabelString, result);
     }
     pushStatement(wrapIntoLabels(result, info.labels));
     return true;
@@ skipping 357 matching lines @@
     HBasicBlock block = node.block;
     assert(block.successors.length == 1);
     List<HBasicBlock> dominated = block.dominatedBlocks;
     // With the exception of the entry-node which dominates its successor
     // and the exit node, no block finishing with a 'goto' can have more than
     // one dominated block (since it has only one successor).
     // If the successor is dominated by another block, then the other block
     // is responsible for visiting the successor.
     if (dominated.isEmpty) return;
     if (dominated.length > 2) {
-      compiler.internalError('dominated.length = ${dominated.length}',
-                             instruction: node);
+      compiler.internalError(node, 'dominated.length = ${dominated.length}');
     }
     if (dominated.length == 2 && block != currentGraph.entry) {
-      compiler.internalError('node.block != currentGraph.entry',
-                             instruction: node);
+      compiler.internalError(node, 'node.block != currentGraph.entry');
     }
     assert(dominated[0] == block.successors[0]);
     visitBasicBlock(dominated[0]);
   }
 
   visitLoopBranch(HLoopBranch node) {
     assert(node.block == subGraph.end);
     // We are generating code for a loop condition.
     // If we are generating the subgraph as an expression, the
     // condition will be generated as the expression.
@@ skipping 63 matching lines @@
     // try/catch block, ie the try body is always a predecessor
     // of the catch and finally. Here, we continue visiting the try
     // body by visiting the block that contains the user-level control
     // flow instruction.
     visitBasicBlock(node.bodyTrySuccessor);
   }
 
   visitTry(HTry node) {
     // We should never get here. Try/catch/finally is always handled using block
     // information in [visitTryInfo].
-    compiler.internalError('visitTry should not be called', instruction: node);
+    compiler.internalError(node, 'visitTry should not be called.');
   }
 
   bool tryControlFlowOperation(HIf node) {
     if (!controlFlowOperators.contains(node)) return false;
     HPhi phi = node.joinBlock.phis.first;
     bool atUseSite = isGenerateAtUseSite(phi);
     // Don't generate a conditional operator in this situation:
     // i = condition ? bar() : i;
     // But generate this instead:
     // if (condition) i = bar();
@@ skipping 309 matching lines @@
       if (type is DartType) {
         world.registerInstantiatedType(type, work.resolutionTree);
       }
     });
   }
 
   visitForeign(HForeign node) {
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement()) {
       if (!inputs.isEmpty) {
-        compiler.internalError("foreign statement with inputs",
-                               instruction: node);
+        compiler.internalError(node, "Foreign statement with inputs.");
       }
       pushStatement(node.codeAst, node);
     } else {
       if (!inputs.isEmpty) {
         List<js.Expression> interpolatedExpressions = <js.Expression>[];
         for (int i = 0; i < inputs.length; i++) {
           use(inputs[i]);
           interpolatedExpressions.add(pop());
         }
         var visitor = new js.UninterpolateJSExpression(interpolatedExpressions);
@@ skipping 779 matching lines @@
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
 
       js.Binary notIndexingTest = checkIndexingBehavior(input, negative: true)
           ? new js.Binary('&&', arrayTest, pop())
           : arrayTest;
       js.Binary notObjectOrIndexingTest =
           new js.Binary('||', objectTest, notIndexingTest);
       test = new js.Binary('&&', stringTest, notObjectOrIndexingTest);
     } else {
-      compiler.internalError('Unexpected check', instruction: input);
+      compiler.internalError(input, 'Unexpected check.');
     }
     return test;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       // An int check if the input is not int or null, is not
       // sufficient for doing a argument or receiver check.
       assert(!node.checkedType.containsOnlyInt(compiler) ||
              node.checkedInput.isIntegerOrNull(compiler));
@@ skipping 145 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = compiler.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     world.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }