Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/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 'dart:convert';
 
 import 'package:package_config/packages.dart';
@@ skipping 217 matching lines @@
     }
     return resolvedUri;
   }
 
   /**
    * Reads the script designated by [readableUri].
    */
   Future<Script> readScript(Spannable node, Uri readableUri) {
     if (!readableUri.isAbsolute) {
       if (node == null) node = NO_LOCATION_SPANNABLE;
-      internalError(node,
+      reporter.internalError(node,
           'Relative uri $readableUri provided to readScript(Uri).');
     }
 
     // We need to store the current element since we are reporting read errors
     // asynchronously and therefore need to restore the current element for
     // [node] to be valid.
     elements.Element element = currentElement;
     void reportReadError(exception) {
       if (element == null || node == null) {
-        reportErrorMessage(
+        reporter.reportErrorMessage(
             new SourceSpan(readableUri, 0, 0),
             MessageKind.READ_SELF_ERROR,
             {'uri': readableUri, 'exception': exception});
       } else {
-        withCurrentElement(element, () {
-          reportErrorMessage(
+        reporter.withCurrentElement(element, () {
+          reporter.reportErrorMessage(
               node,
               MessageKind.READ_SCRIPT_ERROR,
               {'uri': readableUri, 'exception': exception});
         });
       }
     }
 
     Uri resourceUri = translateUri(node, readableUri);
     if (resourceUri == null) return synthesizeScript(node, readableUri);
     if (resourceUri.scheme == 'dart-ext') {
       if (!allowNativeExtensions) {
-        withCurrentElement(element, () {
-          reportErrorMessage(
+        reporter.withCurrentElement(element, () {
+          reporter.reportErrorMessage(
               node, MessageKind.DART_EXT_NOT_SUPPORTED);
         });
       }
       return synthesizeScript(node, readableUri);
     }
 
     // TODO(johnniwinther): Wrap the result from [provider] in a specialized
     // [Future] to ensure that we never execute an asynchronous action without
     // setting up the current element of the compiler.
     return new Future.sync(() => callUserProvider(resourceUri)).then((data) {
@@ skipping 50 matching lines @@
       if (importingLibrary != null) {
         if (importingLibrary.isPlatformLibrary || importingLibrary.isPatch) {
           allowInternalLibraryAccess = true;
         } else if (importingLibrary.canonicalUri.path.contains(
                        'sdk/tests/compiler/dart2js_native')) {
           allowInternalLibraryAccess = true;
         }
       }
       if (!allowInternalLibraryAccess) {
         if (importingLibrary != null) {
-          reportErrorMessage(
+          reporter.reportErrorMessage(
               spannable,
               MessageKind.INTERNAL_LIBRARY_FROM,
               {'resolvedUri': resolvedUri,
                'importingUri': importingLibrary.canonicalUri});
         } else {
-          reportErrorMessage(
+          reporter.reportErrorMessage(
               spannable,
               MessageKind.INTERNAL_LIBRARY,
               {'resolvedUri': resolvedUri});
         }
       }
     }
     if (path == null) {
       if (libraryInfo == null) {
-        reportErrorMessage(
+        reporter.reportErrorMessage(
             spannable,
             MessageKind.LIBRARY_NOT_FOUND,
             {'resolvedUri': resolvedUri});
       } else {
-        reportErrorMessage(
+        reporter.reportErrorMessage(
             spannable,
             MessageKind.LIBRARY_NOT_SUPPORTED,
             {'resolvedUri': resolvedUri});
       }
       // TODO(johnniwinther): Support signaling the error through the returned
       // value.
       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(Spannable node, Uri uri) {
     try {
       checkValidPackageUri(uri);
     } on ArgumentError catch (e) {
-      reportErrorMessage(
+      reporter.reportErrorMessage(
           node,
           MessageKind.INVALID_PACKAGE_URI,
           {'uri': uri, 'exception': e.message});
       return null;
     }
     return packages.resolve(uri,
         notFound: (Uri notFound) {
-          reportErrorMessage(
+          reporter.reportErrorMessage(
               node,
               MessageKind.LIBRARY_NOT_FOUND,
               {'resolvedUri': uri});
           return null;
         });
   }
 
   Future<elements.LibraryElement> analyzeUri(
       Uri uri,
       {bool skipLibraryWithPartOfTag: true}) {
@@ skipping 17 matching lines @@
         // The input provider may put a trailing 0 byte when it reads a source
         // file, which confuses the package config parser.
         if (packageConfigContents.length > 0 &&
             packageConfigContents.last == 0) {
           packageConfigContents = packageConfigContents.sublist(
               0, packageConfigContents.length - 1);
         }
         packages =
             new MapPackages(pkgs.parse(packageConfigContents, packageConfig));
       }).catchError((error) {
-        reportErrorMessage(
+        reporter.reportErrorMessage(
             NO_LOCATION_SPANNABLE,
             MessageKind.INVALID_PACKAGE_CONFIG,
             {'uri': packageConfig, 'exception': error});
         packages = Packages.noPackages;
       });
     } else {
       if (packagesDiscoveryProvider == null) {
         packages = Packages.noPackages;
       } else {
         return callUserPackagesDiscovery(uri).then((p) {
@@ skipping 89 matching lines @@
   Future<Packages> callUserPackagesDiscovery(Uri uri) {
     try {
       return userPackagesDiscoveryTask.measure(
                  () => packagesDiscoveryProvider(uri));
     } catch (ex, s) {
       diagnoseCrashInUserCode('Uncaught exception in package discovery', ex, s);
       rethrow;
     }
   }
 
-  void diagnoseCrashInUserCode(String message, exception, stackTrace) {
-    hasCrashed = true;
-    print('$message: ${tryToString(exception)}');
-    print(tryToString(stackTrace));
-  }
 
   fromEnvironment(String name) => environment[name];
 
   LibraryInfo lookupLibraryInfo(String libraryName) {
     return library_info.LIBRARIES[libraryName];
   }
 }