Clean up error handling.

dart/sdk/lib/_internal/compiler/implementation/library_loader.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 dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 237 matching lines @@
                           LibraryElement library) {
     int tagState = TagState.NO_TAG_SEEN;
 
     /**
      * If [value] is less than [tagState] complain and return
      * [tagState]. Otherwise return the new value for [tagState]
      * (transition function for state machine).
      */
     int checkTag(int value, LibraryTag tag) {
       if (tagState > value) {
-        compiler.reportError(tag, 'out of order');
+        compiler.reportFatalError(
+            tag,
+            MessageKind.GENERIC, {'text': 'Error: Out of order.'});
         return tagState;
       }
       return TagState.NEXT[value];
     }
 
     bool importsDartCore = false;
     var libraryDependencies = new LinkBuilder<LibraryDependency>();
     Uri base = library.entryCompilationUnit.script.uri;
     for (LibraryTag tag in library.tags.reverse()) {
       if (tag.isImport) {
@@ skipping 121 matching lines @@
                               LibraryElement library,
                               LibraryDependency tag) {
     Uri base = library.entryCompilationUnit.script.uri;
     Uri resolvedUri = base.resolve(tag.uri.dartString.slowToString());
     LibraryElement loadedLibrary =
         createLibrary(handler, library, resolvedUri, tag.uri, resolvedUri);
     handler.registerDependency(library, tag, loadedLibrary);
 
     if (!loadedLibrary.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
-        compiler.reportError(tag == null ? null : tag.uri,
-            'no library name found in ${loadedLibrary.canonicalUri}');
+        compiler.reportFatalError(
+            tag == null ? null : tag.uri,
+            MessageKind.GENERIC,
+            {'text':
+             'Error: No library name found in ${loadedLibrary.canonicalUri}.'});
       });
     }
   }
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
@@ skipping 86 matching lines @@
       if (e == null) {
         e = new PrefixElementX(prefix, importingLibrary.entryCompilationUnit,
                                import.getBeginToken());
         importingLibrary.addToScope(e, compiler);
       }
       if (!identical(e.kind, ElementKind.PREFIX)) {
         compiler.withCurrentElement(e, () {
           compiler.reportWarning(new Identifier(e.position()),
           'duplicated definition');
         });
-        compiler.reportError(import.prefix, 'duplicate definition');
+        compiler.reportFatalError(
+            import.prefix,
+            MessageKind.GENERIC, {'text': 'Error: Duplicate definition.'});
       }
       PrefixElement prefixElement = e;
       importedLibrary.forEachExport((Element element) {
         if (combinatorFilter.exclude(element)) return;
         // TODO(johnniwinther): Clean-up like [checkDuplicateLibraryName].
         Element existing =
             prefixElement.imported.putIfAbsent(element.name, () => element);
         if (!identical(existing, element)) {
           compiler.withCurrentElement(existing, () {
             compiler.reportWarning(new Identifier(existing.position()),
             'duplicated import');
           });
           compiler.withCurrentElement(element, () {
-            compiler.reportError(new Identifier(element.position()),
-            'duplicated import');
+            compiler.reportFatalError(
+                element,
+                MessageKind.GENERIC, {'text': 'Error: Duplicated import.'});
           });
         }
       });
     } else {
       importedLibrary.forEachExport((Element element) {
         compiler.withCurrentElement(element, () {
           if (combinatorFilter.exclude(element)) return;
           importingLibrary.addImport(element, import, compiler);
         });
       });
@@ skipping 134 matching lines @@
 
   /**
    * Adds [element] to the export scope for this node. If the [element] name
    * is a duplicate, an error element is inserted into the export scope.
    */
   Element addElementToExportScope(Compiler compiler, Element element) {
     SourceString name = element.name;
     Element existingElement = exportScope[name];
     if (existingElement != null) {
       if (existingElement.isErroneous()) {
-        compiler.reportErrorCode(element, MessageKind.DUPLICATE_EXPORT,
-                                 {'name': name});
+        compiler.reportError(element, MessageKind.DUPLICATE_EXPORT,
+                             {'name': name});
         element = existingElement;
       } else if (existingElement.getLibrary() != library) {
         // Declared elements hide exported elements.
-        compiler.reportErrorCode(existingElement, MessageKind.DUPLICATE_EXPORT,
-                                 {'name': name});
-        compiler.reportErrorCode(element, MessageKind.DUPLICATE_EXPORT,
-                                 {'name': name});
+        compiler.reportError(existingElement, MessageKind.DUPLICATE_EXPORT,
+                             {'name': name});
+        compiler.reportError(element, MessageKind.DUPLICATE_EXPORT,
+                             {'name': name});
         element = exportScope[name] = new ErroneousElementX(
             MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
       }
     } else {
       exportScope[name] = element;
     }
     return element;
   }
 
   /**
@@ skipping 134 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }