Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/resolution/signatures.dart

 // Copyright (c) 2014, 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 resolution;
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<ParameterElementX> {
@@ skipping 28 matching lines @@
     optionalParametersAreNamed = (identical(value, '{'));
     isOptionalParameter = true;
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
     optionalParameters = elements.toLink();
   }
 
   ParameterElementX visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty) {
-      cancel(node, 'internal error: no parameter definition');
+      internalError(node, 'no parameter definition');
       return null;
     }
     if (!definitions.tail.isEmpty) {
-      cancel(definitions.tail.head, 'internal error: extra definition');
+      internalError(definitions.tail.head, 'extra definition');
       return null;
     }
     Node definition = definitions.head;
     if (definition is NodeList) {
-      cancel(node, 'optional parameters are not implemented');
+      internalError(node, 'optional parameters are not implemented');
     }
     if (node.modifiers.isConst()) {
-      error(node, MessageKind.FORMAL_DECLARED_CONST);
+      compiler.reportError(node, MessageKind.FORMAL_DECLARED_CONST);
     }
     if (node.modifiers.isStatic()) {
-      error(node, MessageKind.FORMAL_DECLARED_STATIC);
+      compiler.reportError(node, MessageKind.FORMAL_DECLARED_STATIC);
     }
 
     if (currentDefinitions != null) {
-      cancel(node, 'function type parameters not supported');
+      internalError(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     ParameterElementX element = definition.accept(this);
     if (currentDefinitions.metadata != null) {
       element.metadata = compiler.resolver.resolveMetadata(element, node);
     }
     currentDefinitions = null;
     return element;
   }
 
@@ skipping 38 matching lines @@
     if (identifier != null) {
       // Normal parameter: [:Type name:].
       return identifier;
     } else {
       // Function type parameter: [:void name(DartType arg):].
       var functionExpression = node.selector.asFunctionExpression();
       if (functionExpression != null &&
           functionExpression.name.asIdentifier() != null) {
         return functionExpression.name.asIdentifier();
       } else {
-        cancel(node,
+        internalError(node,
             'internal error: unimplemented receiver on parameter send');
         return null;
       }
     }
   }
 
   // The only valid [Send] can be in constructors and must be of the form
   // [:this.x:] (where [:x:] represents an instance field).
   FieldParameterElementX visitSend(Send node) {
     return createFieldParameter(node, null);
@@ skipping 166 matching lines @@
     if (node == null) return;
     node.accept(resolver);
   }
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }