Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/native_handler.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.
 
 library native;
 
 import 'dart:collection' show Queue;
 import 'dart2jslib.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
@@ skipping 270 matching lines @@
   ClassElement get annotationJsNameClass {
     findAnnotationClasses();
     return _annotationJsNameClass;
   }
 
   void findAnnotationClasses() {
     if (_annotationCreatesClass != null) return;
     ClassElement find(name) {
       Element e = compiler.findHelper(name);
       if (e == null || e is! ClassElement) {
-        compiler.cancel("Could not find implementation class '${name}'");
+        compiler.internalError(NO_LOCATION_SPANNABLE,
+            "Could not find implementation class '${name}'.");
       }
       return e;
     }
     _annotationCreatesClass = find('Creates');
     _annotationReturnsClass = find('Returns');
     _annotationJsNameClass = find('JSName');
   }
 
   /// Returns the JSName annotation string or `null` if no JSName annotation is
   /// present.
   String findJsNameFromAnnotation(Element element) {
     String name = null;
     ClassElement annotationClass = annotationJsNameClass;
     for (Link<MetadataAnnotation> link = element.metadata;
          !link.isEmpty;
          link = link.tail) {
       MetadataAnnotation annotation = link.head.ensureResolved(compiler);
       var value = annotation.value;
       if (value is! ConstructedConstant) continue;
       if (value.type is! InterfaceType) continue;
       if (!identical(value.type.element, annotationClass)) continue;
 
       var fields = value.fields;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || fields[0] is! StringConstant) {
         PartialMetadataAnnotation partial = annotation;
-        compiler.cancel(
+        compiler.internalError(annotation,
             'Annotations needs one string: ${partial.parseNode(compiler)}');
       }
       String specString = fields[0].toDartString().slowToString();
       if (name == null) {
         name = specString;
       } else {
         PartialMetadataAnnotation partial = annotation;
-        compiler.cancel(
+        compiler.internalError(annotation,
             'Too many JSName annotations: ${partial.parseNode(compiler)}');
       }
     }
     return name;
   }
 
   enqueueClass(ClassElement classElement, cause) {
     assert(unusedClasses.contains(classElement));
     unusedClasses.remove(classElement);
     pendingClasses.add(classElement);
@@ skipping 420 matching lines @@
 
   static NativeBehavior ofJsCall(Send jsCall, Compiler compiler, resolver) {
     // The first argument of a JS-call is a string encoding various attributes
     // of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
 
     var argNodes = jsCall.arguments;
     if (argNodes.isEmpty) {
-      compiler.cancel("JS expression has no type", node: jsCall);
+      compiler.internalError(jsCall, "JS expression has no type.");
     }
 
     var code = argNodes.tail.head;
     if (code is !StringNode || code.isInterpolation) {
-      compiler.cancel('JS code must be a string literal', node: code);
+      compiler.internalError(code, 'JS code must be a string literal.');
     }
 
     LiteralString specLiteral = argNodes.head.asLiteralString();
     if (specLiteral == null) {
       // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
       // is not very satisfactory because it does not work for void, dynamic.
-      compiler.cancel("Unexpected JS first argument", node: argNodes.head);
+      compiler.internalError(argNodes.head, "Unexpected JS first argument.");
     }
 
     var behavior = new NativeBehavior();
     behavior.codeAst = js.js.parseForeignJS(code.dartString.slowToString());
     new SideEffectsVisitor(behavior.sideEffects).visit(behavior.codeAst);
 
     String specString = specLiteral.dartString.slowToString();
     // Various things that are not in fact types.
     if (specString == 'void') return behavior;
     if (specString == '' || specString == 'var') {
@@ skipping 94 matching lines @@
       MetadataAnnotation annotation = link.head.ensureResolved(compiler);
       var value = annotation.value;
       if (value is! ConstructedConstant) continue;
       if (value.type is! InterfaceType) continue;
       if (!identical(value.type.element, annotationClass)) continue;
 
       var fields = value.fields;
       // TODO(sra): Better validation of the constant.
       if (fields.length != 1 || fields[0] is! StringConstant) {
         PartialMetadataAnnotation partial = annotation;
-        compiler.cancel(
+        compiler.internalError(annotation,
             'Annotations needs one string: ${partial.parseNode(compiler)}');
       }
       String specString = fields[0].toDartString().slowToString();
       for (final typeString in specString.split('|')) {
         var type = _parseType(typeString, compiler, lookup, annotation);
         if (types == null) types = [];
         types.add(type);
       }
     }
     return types;
@@ skipping 38 matching lines @@
       lookup(name), locationNodeOrElement) {
     if (typeString == '=Object') return SpecialType.JsObject;
     if (typeString == 'dynamic') {
       return  compiler.types.dynamicType;
     }
     DartType type = lookup(typeString);
     if (type != null) return type;
 
     int index = typeString.indexOf('<');
     if (index < 1) {
-      compiler.cancel("Type '$typeString' not found",
-          node: _errorNode(locationNodeOrElement, compiler));
+      compiler.internalError(
+          _errorNode(locationNodeOrElement, compiler),
+          "Type '$typeString' not found.");
     }
     type = lookup(typeString.substring(0, index));
     if (type != null)  {
       // TODO(sra): Parse type parameters.
       return type;
     }
-    compiler.cancel("Type '$typeString' not found",
-        node: _errorNode(locationNodeOrElement, compiler));
+    compiler.internalError(
+        _errorNode(locationNodeOrElement, compiler),
+        "Type '$typeString' not found.");
   }
 
   static _errorNode(locationNodeOrElement, compiler) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(compiler);
   }
 }
 
 void checkAllowedLibrary(ElementListener listener, Token token) {
   LibraryElement currentLibrary = listener.compilationUnitElement.getLibrary();
   if (!currentLibrary.canUseNative) {
-    listener.recoverableError("Unexpected token", token: token);
+    listener.recoverableError(token, "Unexpected token");
   }
 }
 
 Token handleNativeBlockToSkip(Listener listener, Token token) {
   checkAllowedLibrary(listener, token);
   token = token.next;
   if (identical(token.kind, STRING_TOKEN)) {
     token = token.next;
   }
   if (identical(token.stringValue, '{')) {
@@ skipping 88 matching lines @@
   //      No longer supported, this is now done with @JSName('foo') and case 1.
   // 3) foo() native "return 42";
   //      hasBody = true
   bool hasBody = false;
   assert(element.isNative());
   String nativeMethodName = element.fixedBackendName();
   if (nativeBody != null) {
     LiteralString jsCode = nativeBody.asLiteralString();
     String str = jsCode.dartString.slowToString();
     if (nativeRedirectionRegExp.hasMatch(str)) {
-      compiler.cancel("Deprecated syntax, use @JSName('name') instead.",
-                      node: nativeBody);
+      compiler.internalError(
+          nativeBody, "Deprecated syntax, use @JSName('name') instead.");
     }
     hasBody = true;
   }
 
   if (!hasBody) {
     nativeEmitter.nativeMethods.add(element);
   }
 
   FunctionSignature parameters = element.functionSignature;
   if (!hasBody) {
@@ skipping 18 matching lines @@
 
     String foreignParameters = arguments.join(',');
     String nativeMethodCall;
     if (element.kind == ElementKind.FUNCTION) {
       nativeMethodCall = '$receiver$nativeMethodName($foreignParameters)';
     } else if (element.kind == ElementKind.GETTER) {
       nativeMethodCall = '$receiver$nativeMethodName';
     } else if (element.kind == ElementKind.SETTER) {
       nativeMethodCall = '$receiver$nativeMethodName = $foreignParameters';
     } else {
-      builder.compiler.internalError('unexpected kind: "${element.kind}"',
-                                     element: element);
+      builder.compiler.internalError(element,
+                                     'Unexpected kind: "${element.kind}".');
     }
 
     builder.push(new HForeign(js.js(nativeMethodCall), backend.dynamicType,
                               inputs, effects: new SideEffects()));
     builder.close(new HReturn(builder.pop())).addSuccessor(builder.graph.exit);
   } else {
     if (parameters.parameterCount != 0) {
-      compiler.cancel(
-          'native "..." syntax is restricted to functions with zero parameters',
-          node: nativeBody);
+      compiler.internalError(nativeBody,
+          'native "..." syntax is restricted to '
+          'functions with zero parameters.');
     }
     LiteralString jsCode = nativeBody.asLiteralString();
     builder.push(new HForeign.statement(
         new js.LiteralStatement(jsCode.dartString.slowToString()),
         <HInstruction>[],
         new SideEffects(),
         null,
         backend.dynamicType));
   }
 }