Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 265 matching lines @@
         cls.ensureResolved(compiler);
         return null;
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         return resolveTypedef(typdef);
       } else if (element.isTypeVariable()) {
         element.computeType(compiler);
         return null;
       }
 
-      compiler.unimplemented("resolve($element)",
-                             node: element.parseNode(compiler));
+      compiler.unimplemented(element, "resolve($element)");
     });
   }
 
   String constructorNameForDiagnostics(String className,
                                        String constructorName) {
     String classNameString = className;
     String constructorNameString = constructorName;
     return (constructorName == '')
         ? classNameString
         : "$classNameString.$constructorNameString";
@@ skipping 681 matching lines @@
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter()) return;
 
     // Find the associated abstract field.
     ClassElement classElement = member.getEnclosingClass();
     Element lookupElement = classElement.lookupLocalMember(member.name);
     if (lookupElement == null) {
-      compiler.internalErrorOnElement(member,
-                                      "No abstract field for accessor");
+      compiler.internalError(member,
+          "No abstract field for accessor");
     } else if (!identical(lookupElement.kind, ElementKind.ABSTRACT_FIELD)) {
-       compiler.internalErrorOnElement(
-           member, "Inaccessible abstract field for accessor");
+      compiler.internalError(member,
+          "Inaccessible abstract field for accessor");
     }
     AbstractFieldElement field = lookupElement;
 
     if (field.getter == null) return;
     if (field.setter == null) return;
     int getterFlags = field.getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     int setterFlags = field.setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     if (!identical(getterFlags, setterFlags)) {
       final mismatchedFlags =
         new Modifiers.withFlags(null, getterFlags ^ setterFlags);
@@ skipping 30 matching lines @@
       messageKind = MessageKind.UNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 0;
     } else if (isBinaryOperator(value)) {
       messageKind = MessageKind.BINARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
       if (identical(value, '==')) checkOverrideHashCode(member);
     } else if (isTernaryOperator(value)) {
       messageKind = MessageKind.TERNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 2;
     } else {
-      compiler.internalErrorOnElement(function,
+      compiler.internalError(function,
           'Unexpected user defined operator $value');
     }
     checkArity(function, requiredParameterCount, messageKind, isMinus);
   }
 
   void checkOverrideHashCode(FunctionElement operatorEquals) {
     if (operatorEquals.isAbstract) return;
     ClassElement cls = operatorEquals.getEnclosingClass();
     Element hashCodeImplementation =
         cls.lookupLocalMember('hashCode');
@@ skipping 471 matching lines @@
     return null;  // If there was no redirection always return null.
   }
 }
 
 class CommonResolverVisitor<R> extends Visitor<R> {
   final Compiler compiler;
 
   CommonResolverVisitor(Compiler this.compiler);
 
   R visitNode(Node node) {
-    cancel(node,
-           'internal error: Unhandled node: ${node.getObjectDescription()}');
+    internalError(node,
+        'internal error: Unhandled node: ${node.getObjectDescription()}');
     return null;
   }
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Spannable node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportFatalError(node, kind, arguments);
   }
 
   void warning(Spannable node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportWarning(node, kind, arguments);
   }
 
-  void cancel(Node node, String message) {
-    compiler.cancel(message, node: node);
-  }
-
-  void internalError(Node node, String message) {
-    compiler.internalError(message, node: node);
+  void internalError(Spannable node, message) {
+    compiler.internalError(node, message);
   }
 
   void addDeferredAction(Element element, DeferredAction action) {
     compiler.enqueuer.resolution.addDeferredAction(element, action);
   }
 }
 
 abstract class LabelScope {
   LabelScope get outer;
   LabelElement lookup(String label);
@@ skipping 262 matching lines @@
           compiler.backend.registerThrowRuntimeError(visitor.mapping);
           type = reportFailureAndCreateType(
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node},
               userProvidedBadType: element.computeType(compiler));
         } else {
           type = element.computeType(compiler);
         }
         type = checkNoTypeArguments(type);
       } else {
-        compiler.cancel("unexpected element kind ${element.kind}",
-                        node: node);
+        compiler.internalError(node,
+            "Unexpected element kind ${element.kind}.");
       }
       // TODO(johnniwinther): We should not resolve type annotations after the
       // resolution queue has been closed. Currently the dart backend does so.
       // Remove the guarded when this is fixed.
       if (!compiler.enqueuer.resolution.queueIsClosed &&
           addTypeVariableBoundsCheck) {
         visitor.addDeferredAction(
             visitor.enclosingElement,
             () => checkTypeVariableBounds(visitor.mapping, node, type));
       }
@@ skipping 404 matching lines @@
 
   visitCascade(Cascade node) {
     visit(node.expression);
   }
 
   visitCascadeReceiver(CascadeReceiver node) {
     visit(node.expression);
   }
 
   visitClassNode(ClassNode node) {
-    cancel(node, "shouldn't be called");
+    internalError(node, "shouldn't be called");
   }
 
   visitIn(Node node, Scope nestedScope) {
     Scope oldScope = scope;
     scope = nestedScope;
     Element element = visit(node);
     scope = oldScope;
     return element;
   }
 
@@ skipping 594 matching lines @@
 
   visitLiteralNull(LiteralNull node) {
     world.registerInstantiatedClass(compiler.nullClass, mapping);
   }
 
   visitLiteralSymbol(LiteralSymbol node) {
     world.registerInstantiatedClass(compiler.symbolClass, mapping);
     world.registerStaticUse(compiler.symbolConstructor.declaration);
     world.registerConstSymbol(node.slowNameString, mapping);
     if (!validateSymbol(node, node.slowNameString, reportError: false)) {
-      compiler.reportInternalError(node,
+      compiler.reportError(node,
           MessageKind.UNSUPPORTED_LITERAL_SYMBOL,
           {'value': node.slowNameString});
     }
     analyzeConstant(node);
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
     node.visitChildren(this);
   }
@@ skipping 1089 matching lines @@
     }
     // If the super type isn't specified, we provide a default.  The language
     // specifies [Object] but the backend can pick a specific 'implementation'
     // of Object - the JavaScript backend chooses between Object and
     // Interceptor.
     if (element.supertype == null) {
       ClassElement superElement = compiler.backend.defaultSuperclass(element);
       // Avoid making the superclass (usually Object) extend itself.
       if (element != superElement) {
         if (superElement == null) {
-          compiler.internalError(
-              "Cannot resolve default superclass for $element",
-              node: node);
+          compiler.internalError(node,
+              "Cannot resolve default superclass for $element.");
         } else {
           superElement.ensureResolved(compiler);
         }
         element.supertype = superElement.computeType(compiler);
       }
     }
 
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
@@ skipping 680 matching lines @@
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 }