Clean up error handling.

dart/sdk/lib/_internal/compiler/implementation/apiimpl.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 leg_apiimpl;
 
 import 'dart:async';
 
 import '../compiler.dart' as api;
 import 'dart2jslib.dart' as leg;
@@ skipping 159 matching lines @@
       Uri resourceUri = translateUri(readableUri, node);
       String text = "";
       try {
         // TODO(ahe): We expect the future to be complete and call value
         // directly. In effect, we don't support truly asynchronous API.
         text = deprecatedFutureValue(provider(resourceUri));
       } catch (exception) {
         if (node != null) {
           cancel("$exception", node: node);
         } else {
-          reportDiagnostic(null, "$exception", api.Diagnostic.ERROR);
+          reportError(
+              null,
+              leg.MessageKind.GENERIC, {'text': 'Error: $exception'});
           throw new leg.CompilerCancelledException("$exception");
         }
       }
       SourceFile sourceFile = new SourceFile(resourceUri.toString(), text);
       // We use [readableUri] as the URI for the script since need to preserve
       // the scheme in the script because [Script.uri] is used for resolving
       // relative URIs mentioned in the script. See the comment on
       // [LibraryLoader] for more details.
       return new leg.Script(readableUri, sourceFile);
     });
@@ skipping 21 matching lines @@
       if (importingLibrary != null) {
         if (importingLibrary.isPlatformLibrary || importingLibrary.isPatch) {
           allowInternalLibraryAccess = true;
         } else if (importingLibrary.canonicalUri.path.contains(
                        'dart/tests/compiler/dart2js_native')) {
           allowInternalLibraryAccess = true;
         }
       }
       if (!allowInternalLibraryAccess) {
         if (node != null && importingLibrary != null) {
-          reportDiagnostic(spanFromNode(node),
-              'Error: Internal library $resolvedUri is not accessible from '
-              '${importingLibrary.canonicalUri}.',
-              api.Diagnostic.ERROR);
+          reportError(
+              node,
+              leg.MessageKind.GENERIC,
+              {'text':
+                  'Error: Internal library $resolvedUri is not accessible from '
+                  '${importingLibrary.canonicalUri}.'});
         } else {
-          reportDiagnostic(null,
-              'Error: Internal library $resolvedUri is not accessible.',
-              api.Diagnostic.ERROR);
+          reportError(
+              null,
+              leg.MessageKind.GENERIC,
+              {'text':
+                  'Error: Internal library $resolvedUri is not accessible.'});
         }
-        //path = null;
       }
     }
     if (path == null) {
       if (node != null) {
-        reportError(node, 'library not found ${resolvedUri}');
+        reportError(
+            node,
+            leg.MessageKind.GENERIC,
+            {'text': 'Error: Library not found ${resolvedUri}.'});
       } else {
-        reportDiagnostic(null, 'library not found ${resolvedUri}',
-                         api.Diagnostic.ERROR);
+        reportError(
+            null,
+            leg.MessageKind.GENERIC,
+            {'text': 'Error: Library not found ${resolvedUri}.'});
       }
       return null;
     }
     if (resolvedUri.path == 'html' ||
         resolvedUri.path == 'io') {
       // TODO(ahe): Get rid of mockableLibraryUsed when test.dart
       // supports this use case better.
       mockableLibraryUsed = true;
     }
     return libraryRoot.resolve(path);
   }
 
   Uri resolvePatchUri(String dartLibraryPath) {
     String patchPath = lookupPatchPath(dartLibraryPath);
     if (patchPath == null) return null;
     return libraryRoot.resolve(patchPath);
   }
 
   Uri translatePackageUri(Uri uri, tree.Node node) {
     if (packageRoot == null) {
-      if (node != null) {
-        reportErrorCode(node,
-            leg.MessageKind.PACKAGE_ROOT_NOT_SET,
-            {'uri': uri});
-      } else {
-        reportDiagnostic(null,
-            leg.MessageKind.PACKAGE_ROOT_NOT_SET.error({'uri': uri}).toString(),
-            api.Diagnostic.ERROR);
-      }
-      throw new leg.CompilerCancelledException("Package root not set.");
+      reportFatalError(
+          node, leg.MessageKind.PACKAGE_ROOT_NOT_SET, {'uri': uri});
     }
     return packageRoot.resolve(uri.path);
   }
 
   bool run(Uri uri) {
     log('Allowed library categories: $allowedLibraryCategories');
     bool success = super.run(uri);
     int cumulated = 0;
     for (final task in tasks) {
       cumulated += task.timing;
@@ skipping 19 matching lines @@
       handler(translateUri(span.uri, null), span.begin, span.end,
               message, kind);
     }
   }
 
   bool get isMockCompilation {
     return mockableLibraryUsed
       && (options.indexOf('--allow-mock-compilation') != -1);
   }
 }