Remove cancel and make crash exit with code 253.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 30 matching lines @@
   final int hashCode = ++elementHashCode;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isErroneous() || getImplementationLibrary() != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(DiagnosticListener listener) {
-    listener.internalErrorOnElement(this, 'not implemented');
+    listener.internalError(this, 'Not implemented.');
     return null;
   }
 
   DartType computeType(Compiler compiler) {
-    compiler.internalError("$this.computeType.", token: position());
+    compiler.internalError(this, "$this.computeType.");
     return null;
   }
 
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement == null);
     annotation.annotatedElement = this;
     addMetadataInternal(annotation);
   }
 
   void addMetadataInternal(MetadataAnnotation annotation) {
@@ skipping 468 matching lines @@
    * The abstract field should not be treated as a proper member of the
    * container, it's simply a way to return two results for one lookup.
    * That is, the getter or setter does not have the abstract field as enclosing
    * element, they are enclosed by the class or compilation unit, as is the
    * abstract field.
    */
   void addAccessor(Element accessor,
                    Element existing,
                    DiagnosticListener listener) {
     void reportError(Element other) {
-      // TODO(ahe): Do something similar to Resolver.reportErrorWithContext.
-      listener.cancel('duplicate definition of ${accessor.name}',
-                      element: accessor);
-      listener.cancel('existing definition', element: other);
+      listener.reportError(accessor,
+                           MessageKind.DUPLICATE_DEFINITION,
+                           {'name': accessor.name});
+      // TODO(johnniwinther): Make this an info instead of a fatal error.
+      listener.reportFatalError(other,
+                                MessageKind.EXISTING_DEFINITION,
+                                {'name': accessor.name});
     }
 
     if (existing != null) {
       if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
         reportError(existing);
       } else {
         AbstractFieldElementX field = existing;
         if (accessor.isGetter()) {
           if (field.getter != null && field.getter != accessor) {
             reportError(field.getter);
@@ skipping 620 matching lines @@
         if (identical(name, identifier.source)) {
           node = initializedIdentifier;
           initializerCache = sendSet.arguments.first;
         }
       } else if (identical(name, identifier.source)) {
         node = initializedIdentifier;
       }
       count++;
     }
     if (node == null) {
-      listener.cancel('internal error: could not find $name',
-                      node: definitions);
+      listener.internalError(definitions,
+                             "Could not find '$name'.");
     }
     if (count == 1) {
       definitionsCache = definitions;
     } else {
       // Create a [VariableDefinitions] node for the single definition of
       // [node].
       definitionsCache = new VariableDefinitions(definitions.type,
           definitions.modifiers, new NodeList(
               definitions.definitions.beginToken,
               const Link<Node>().prepend(node),
@@ skipping 410 matching lines @@
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionExpression parseNode(DiagnosticListener listener) {
     if (patch == null) {
       if (modifiers.isExternal()) {
-        listener.cancel("Compiling external function with no implementation.",
-                        element: this);
+        listener.internalError(this,
+            "Compiling external function with no implementation.");
       }
     }
     return cachedNode;
   }
 
   Token position() {
     // Use the name as position if this is not an unnamed closure.
     if (cachedNode.name != null) {
       return cachedNode.name.getBeginToken();
     } else {
@@ skipping 31 matching lines @@
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement, false) {
     functionSignature = constructor.functionSignature;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) {
-    compiler.internalErrorOnElement(this, '$this.computeType.');
+    compiler.internalError(this, '$this.computeType.');
     return null;
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode != null);
     return cachedNode;
   }
 
@@ skipping 692 matching lines @@
   }
 
   void forEachLocalMember(void f(Element member)) {
     constructors.forEach(f);
     if (mixin != null) mixin.forEachLocalMember((Element mixedInElement) {
       if (mixedInElement.isInstanceMember()) f(mixedInElement);
     });
   }
 
   void addMember(Element element, DiagnosticListener listener) {
-    throw new UnsupportedError("cannot add member to $this");
+    throw new UnsupportedError("Cannot add member to $this.");
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
-    listener.internalError('cannot add to scope of $this', element: this);
+    listener.internalError(this, 'Cannot add to scope of $this.');
   }
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
@@ skipping 168 matching lines @@
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }