Report info messages together with their error, warning, or hint.

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';
 import 'package:package_config/packages_file.dart' as pkgs;
 import 'package:package_config/src/packages_impl.dart' show
     MapPackages,
     NonFilePackagesDirectoryPackages;
 import 'package:package_config/src/util.dart' show
     checkValidPackageUri;
 import 'package:sdk_library_metadata/libraries.dart' hide LIBRARIES;
 import 'package:sdk_library_metadata/libraries.dart' as library_info show
     LIBRARIES;
 
 import '../compiler_new.dart' as api;
 import 'commandline_options.dart';
 import 'common/tasks.dart' show
     GenericTask;
 import 'compiler.dart' as leg;
+import 'diagnostics/diagnostic_listener.dart' show
+    DiagnosticMessage;
 import 'diagnostics/messages.dart';
 import 'diagnostics/source_span.dart' show
     SourceSpan;
 import 'diagnostics/spannable.dart' show
     NO_LOCATION_SPANNABLE,
     Spannable;
 import 'elements/elements.dart' as elements;
 import 'io/source_file.dart';
 import 'script.dart';
-import 'tree/tree.dart' as tree;
 
 const bool forceIncrementalSupport =
     const bool.fromEnvironment('DART2JS_EXPERIMENTAL_INCREMENTAL_SUPPORT');
 
 class Compiler extends leg.Compiler {
   api.CompilerInput provider;
   api.CompilerDiagnostics handler;
   final Uri libraryRoot;
   final Uri packageConfig;
   final Uri packageRoot;
@@ skipping 193 matching lines @@
       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) {
-        reportError(
+        reportErrorMessage(
             new SourceSpan(readableUri, 0, 0),
             MessageKind.READ_SELF_ERROR,
             {'uri': readableUri, 'exception': exception});
       } else {
         withCurrentElement(element, () {
-          reportError(
+          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, () {
-          reportError(node, MessageKind.DART_EXT_NOT_SUPPORTED);
+          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) {
       SourceFile sourceFile;
@@ skipping 49 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) {
-          reportError(
+          reportErrorMessage(
               spannable,
               MessageKind.INTERNAL_LIBRARY_FROM,
               {'resolvedUri': resolvedUri,
                'importingUri': importingLibrary.canonicalUri});
         } else {
-          reportError(
+          reportErrorMessage(
               spannable,
               MessageKind.INTERNAL_LIBRARY,
               {'resolvedUri': resolvedUri});
         }
       }
     }
     if (path == null) {
       if (libraryInfo == null) {
-        reportError(spannable, MessageKind.LIBRARY_NOT_FOUND,
-                    {'resolvedUri': resolvedUri});
+        reportErrorMessage(
+            spannable,
+            MessageKind.LIBRARY_NOT_FOUND,
+            {'resolvedUri': resolvedUri});
       } else {
-        reportError(spannable, MessageKind.LIBRARY_NOT_SUPPORTED,
-                    {'resolvedUri': resolvedUri});
+        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) {
-      reportError(
+      reportErrorMessage(
           node,
           MessageKind.INVALID_PACKAGE_URI,
           {'uri': uri, 'exception': e.message});
       return null;
     }
     return packages.resolve(uri,
         notFound: (Uri notFound) {
-          reportError(
+          reportErrorMessage(
               node,
               MessageKind.LIBRARY_NOT_FOUND,
-              {'resolvedUri': uri}
-          );
+              {'resolvedUri': uri});
           return null;
         });
   }
 
   Future<elements.LibraryElement> analyzeUri(
       Uri uri,
       {bool skipLibraryWithPartOfTag: true}) {
     if (packages == null) {
       return setupPackages(uri).then((_) => super.analyzeUri(uri));
     }
@@ skipping 14 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) {
-        reportError(NO_LOCATION_SPANNABLE, MessageKind.INVALID_PACKAGE_CONFIG,
+        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) {
           packages = p;
         });
@@ skipping 18 matching lines @@
           }
         }
         int total = totalCompileTime.elapsedMilliseconds;
         log('Total compile-time ${total}msec;'
             ' unaccounted ${total - cumulated}msec');
         return success;
       });
     });
   }
 
-  void reportDiagnostic(Spannable node,
-                        Message message,
+  void reportDiagnostic(DiagnosticMessage message,
+                        List<DiagnosticMessage> infos,
                         api.Diagnostic kind) {
-    SourceSpan span = spanFromSpannable(node);
-    if (identical(kind, api.Diagnostic.ERROR)
-        || identical(kind, api.Diagnostic.CRASH)
-        || (fatalWarnings && identical(kind, api.Diagnostic.WARNING))) {
+    if (kind == api.Diagnostic.ERROR ||
+        kind == api.Diagnostic.CRASH ||
+        (fatalWarnings && kind == api.Diagnostic.WARNING)) {
       compilationFailed = true;
     }
+    _reportDiagnosticMessage(message, kind);
+    for (DiagnosticMessage info in infos) {
+      _reportDiagnosticMessage(info, api.Diagnostic.INFO);
+    }
+  }
+
+  void _reportDiagnosticMessage(DiagnosticMessage diagnosticMessage,
+                                api.Diagnostic kind) {
     // [:span.uri:] might be [:null:] in case of a [Script] with no [uri]. For
     // instance in the [Types] constructor in typechecker.dart.
+    SourceSpan span = diagnosticMessage.sourceSpan;
+    Message message = diagnosticMessage.message;
     if (span == null || span.uri == null) {
       callUserHandler(message, null, null, null, '$message', kind);
     } else {
       callUserHandler(
           message, span.uri, span.begin, span.end, '$message', kind);
     }
   }
 
   bool get isMockCompilation {
     return mockableLibraryUsed
@@ skipping 37 matching lines @@
     print('$message: ${tryToString(exception)}');
     print(tryToString(stackTrace));
   }
 
   fromEnvironment(String name) => environment[name];
 
   LibraryInfo lookupLibraryInfo(String libraryName) {
     return library_info.LIBRARIES[libraryName];
   }
 }