Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/compile_time_constants.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 dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 208 matching lines @@
     if (preSortCompare != null) {
       sorted.sort(preSortCompare);
     }
     sorted.forEach(addConstant);
     return result;
   }
 
   Constant getInitialValueFor(VariableElement element) {
     Constant initialValue = initialVariableValues[element.declaration];
     if (initialValue == null) {
-      compiler.internalError("No initial value for given element",
-                             element: element);
+      compiler.internalError(element, "No initial value for given element.");
     }
     return initialValue;
   }
 }
 
 class CompileTimeConstantEvaluator extends Visitor {
   bool isEvaluatingConstant;
   final ConstantHandler handler;
   final TreeElements elements;
   final Compiler compiler;
@@ skipping 254 matching lines @@
         case "!":
           folded = constantSystem.not.fold(receiverConstant);
           break;
         case "-":
           folded = constantSystem.negate.fold(receiverConstant);
           break;
         case "~":
           folded = constantSystem.bitNot.fold(receiverConstant);
           break;
         default:
-          compiler.internalError("Unexpected operator.", node: op);
+          compiler.internalError(op, "Unexpected operator.");
           break;
       }
       if (folded == null) return signalNotCompileTimeConstant(send);
       return folded;
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
       Constant left = evaluate(send.receiver);
       Constant right = evaluate(send.argumentsNode.nodes.head);
       if (left == null || right == null) return null;
       Operator op = send.selector.asOperator();
@@ skipping 325 matching lines @@
               compiler,
               isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
   }
 
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       Constant constant = definitions[element];
       if (constant == null) {
-        compiler.internalError("Local variable without value", node: send);
+        compiler.internalError(send, "Local variable without value.");
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(Node node,
                             TypedElement element,
                             Constant constant) {
     if (compiler.enableTypeAssertions) {
@@ skipping 103 matching lines @@
       if (enclosingClass != compiler.objectClass) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
 
         Selector selector =
             new Selector.callDefaultConstructor(enclosingClass.getLibrary());
 
         FunctionElement targetConstructor =
             superClass.lookupConstructor(selector);
         if (targetConstructor == null) {
-          compiler.internalError("no default constructor available",
-                                 node: functionNode);
+          compiler.internalError(functionNode,
+              "No default constructor available.");
         }
         List<Constant> compiledArguments = evaluateArgumentsToConstructor(
             functionNode, selector, const Link<Node>(), targetConstructor);
         evaluateSuperOrRedirectSend(compiledArguments, targetConstructor);
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
@@ skipping 15 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }