Clean up error handling.

dart/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 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 
 import '../dart2jslib.dart' show invariant,
                                  InterfaceType,
                                  DartType,
                                  TypeVariableType,
                                  TypedefType,
+                                 DualKind,
                                  MessageKind,
                                  DiagnosticListener,
                                  Script,
                                  FunctionType,
                                  SourceString,
                                  Selector,
                                  Constant,
                                  Compiler;
 
 import '../dart_types.dart';
@@ skipping 325 matching lines @@
  * An ambiguous element represents multiple elements accessible by the same name.
  *
  * Ambiguous elements are created during handling of import/export scopes. If an
  * ambiguous element is encountered during resolution a warning/error should be
  * reported.
  */
 class AmbiguousElementX extends ElementX implements AmbiguousElement {
   /**
    * The message to report on resolving this element.
    */
-  final MessageKind messageKind;
+  final DualKind messageKind;
 
   /**
    * The message arguments to report on resolving this element.
    */
   final Map messageArguments;
 
   /**
    * The first element that this ambiguous element might refer to.
    */
   final Element existingElement;
@@ skipping 52 matching lines @@
     return contents[name];
   }
 
   void add(Element element, DiagnosticListener listener) {
     SourceString name = element.name;
     if (element.isAccessor()) {
       addAccessor(element, contents[name], listener);
     } else {
       Element existing = contents.putIfAbsent(name, () => element);
       if (!identical(existing, element)) {
-        listener.reportErrorCode(element,
-            MessageKind.DUPLICATE_DEFINITION, {'name': name});
+        listener.reportError(
+            element, MessageKind.DUPLICATE_DEFINITION, {'name': name});
         listener.reportMessage(
             listener.spanFromSpannable(existing),
             MessageKind.EXISTING_DEFINITION.error({'name': name}),
             api.Diagnostic.INFO);
       }
     }
   }
 
   /**
    * Adds a definition for an [accessor] (getter or setter) to a scope.
@@ skipping 82 matching lines @@
   void setPartOf(PartOf tag, DiagnosticListener listener) {
     LibraryElementX library = enclosingElement;
     if (library.entryCompilationUnit == this) {
       listener.reportMessage(
           listener.spanFromSpannable(tag),
           MessageKind.ILLEGAL_DIRECTIVE.error(),
           api.Diagnostic.WARNING);
       return;
     }
     if (!localMembers.isEmpty) {
-      listener.reportErrorCode(tag, MessageKind.BEFORE_TOP_LEVEL);
+      listener.reportError(tag, MessageKind.BEFORE_TOP_LEVEL);
       return;
     }
     if (partTag != null) {
       listener.reportMessage(
           listener.spanFromSpannable(tag),
           MessageKind.DUPLICATED_PART_OF.error(),
           api.Diagnostic.WARNING);
       return;
     }
     partTag = tag;
@@ skipping 817 matching lines @@
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement) {
     functionSignature = constructor.functionSignature;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) {
-    compiler.reportFatalError('Internal error: $this.computeType', this);
+    compiler.internalErrorOnElement(this, '$this.computeType.');
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode != null);
     return cachedNode;
   }
 
   Token position() => constructor.position();
@@ skipping 789 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }