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

pkg/compiler/lib/src/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.
 
 library dart2js.library_loader;
 
 import 'dart:async';
 
 import 'common/names.dart' show
     Uris;
@@ skipping 377 matching lines @@
     Uri base = library.entryCompilationUnit.script.readableUri;
 
     return Future.forEach(library.tags, (LibraryTag tag) {
       return compiler.withCurrentElement(library, () {
 
         Uri computeUri(LibraryDependency node) {
           String tagUriString = node.uri.dartString.slowToString();
           try {
             return Uri.parse(tagUriString);
           } on FormatException {
-            compiler.reportError(
+            compiler.reportErrorMessage(
                 node.uri,
                 MessageKind.INVALID_URI, {'uri': tagUriString});
             return null;
           }
         }
 
         if (tag.isImport) {
           Uri uri = computeUri(tag);
           if (uri == null) {
             // Skip this erroneous import.
@@ skipping 66 matching lines @@
   }
 
   void checkDuplicatedLibraryName(LibraryElement library) {
     if (library.isInternalLibrary) return;
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     LibraryElement existing =
         libraryResourceUriMap.putIfAbsent(resourceUri, () => library);
     if (!identical(existing, library)) {
       if (library.hasLibraryName) {
         compiler.withCurrentElement(library, () {
-          compiler.reportWarning(library,
+          compiler.reportWarningMessage(
+              library,
               MessageKind.DUPLICATED_LIBRARY_RESOURCE,
               {'libraryName': library.libraryName,
                'resourceUri': resourceUri,
                'canonicalUri1': library.canonicalUri,
                'canonicalUri2': existing.canonicalUri});
         });
       } else {
-        compiler.reportHint(library,
+        compiler.reportHintMessage(
+            library,
             MessageKind.DUPLICATED_RESOURCE,
             {'resourceUri': resourceUri,
              'canonicalUri1': library.canonicalUri,
              'canonicalUri2': existing.canonicalUri});
       }
     } else if (library.hasLibraryName) {
       String name = library.libraryOrScriptName;
       existing = libraryNames.putIfAbsent(name, () => library);
       if (!identical(existing, library)) {
         compiler.withCurrentElement(library, () {
-          compiler.reportWarning(library,
+          compiler.reportWarningMessage(
+              library,
               MessageKind.DUPLICATED_LIBRARY_NAME,
               {'libraryName': name});
         });
         compiler.withCurrentElement(existing, () {
-          compiler.reportWarning(existing,
+          compiler.reportWarningMessage(
+              existing,
               MessageKind.DUPLICATED_LIBRARY_NAME,
               {'libraryName': name});
         });
       }
     }
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
   Future scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
     if (readableUri == null) return new Future.value();
     return compiler.withCurrentElement(library, () {
       return compiler.readScript(part, readableUri).
           then((Script sourceScript) {
             if (sourceScript == null) return;
 
             CompilationUnitElementX unit =
                 new CompilationUnitElementX(sourceScript, library);
             compiler.withCurrentElement(unit, () {
               compiler.scanner.scan(unit);
               if (unit.partTag == null && !sourceScript.isSynthesized) {
-                compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
+                compiler.reportErrorMessage(
+                    unit, MessageKind.MISSING_PART_OF_TAG);
               }
             });
           });
     });
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope. If the tag does not contain a valid URI, then its dependency
@@ skipping 146 matching lines @@
           } else if (tag.isExport) {
             kind = MessageKind.EXPORT_BEFORE_PARTS;
           } else {
             listener.internalError(tag, "Expected import or export.");
           }
           break;
 
         default:
           listener.internalError(tag, "Unexpected order of library tags.");
       }
-      listener.reportError(tag, kind);
+      listener.reportErrorMessage(tag, kind);
     }
     tagState = NEXT[value];
     if (value == LIBRARY) {
       hasLibraryDeclaration = true;
     }
   }
 }
 
 /**
  * An [import] tag and the [importedLibrary] imported through [import].
@@ skipping 211 matching lines @@
     return pendingExports;
   }
 
   /**
    * 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,
                                   Link<ExportElement> exports) {
     String name = element.name;
+    DiagnosticMessage error;
+    List<DiagnosticMessage> infos = <DiagnosticMessage>[];
 
-    void reportDuplicateExport(Element duplicate,
-                               Link<ExportElement> duplicateExports,
-                               {bool reportError: true}) {
+    void createDuplicateExportMessage(
+        Element duplicate,
+        Link<ExportElement> duplicateExports) {
       assert(invariant(library, !duplicateExports.isEmpty,
           message: "No export for $duplicate from ${duplicate.library} "
                    "in $library."));
       compiler.withCurrentElement(library, () {
         for (ExportElement export in duplicateExports) {
-          if (reportError) {
-            compiler.reportError(export,
-                MessageKind.DUPLICATE_EXPORT, {'name': name});
-            reportError = false;
+          if (error == null) {
+            error = compiler.createMessage(
+                export,
+                MessageKind.DUPLICATE_EXPORT,
+                {'name': name});
           } else {
-            compiler.reportInfo(export,
-                MessageKind.DUPLICATE_EXPORT_CONT, {'name': name});
+            infos.add(compiler.createMessage(
+                export,
+                MessageKind.DUPLICATE_EXPORT_CONT,
+                {'name': name}));
           }
         }
       });
     }
 
-    void reportDuplicateExportDecl(Element duplicate,
-                                   Link<ExportElement> duplicateExports) {
+    void createDuplicateExportDeclMessage(
+        Element duplicate,
+        Link<ExportElement> duplicateExports) {
       assert(invariant(library, !duplicateExports.isEmpty,
           message: "No export for $duplicate from ${duplicate.library} "
                    "in $library."));
-      compiler.reportInfo(duplicate, MessageKind.DUPLICATE_EXPORT_DECL,
-          {'name': name, 'uriString': duplicateExports.head.uri});
+      infos.add(compiler.createMessage(
+          duplicate,
+              MessageKind.DUPLICATE_EXPORT_DECL,
+          {'name': name, 'uriString': duplicateExports.head.uri}));
     }
 
     Element existingElement = exportScope[name];
     if (existingElement != null && existingElement != element) {
       if (existingElement.isErroneous) {
-        reportDuplicateExport(element, exports);
-        reportDuplicateExportDecl(element, exports);
+        createDuplicateExportMessage(element, exports);
+        createDuplicateExportDeclMessage(element, exports);
         element = existingElement;
       } else if (existingElement.library == library) {
         // Do nothing. [existingElement] hides [element].
       } else if (element.library == library) {
         // [element] hides [existingElement].
         exportScope[name] = element;
         exporters[element] = exports;
       } else {
         // Declared elements hide exported elements.
         Link<ExportElement> existingExports = exporters[existingElement];
-        reportDuplicateExport(existingElement, existingExports);
-        reportDuplicateExport(element, exports, reportError: false);
-        reportDuplicateExportDecl(existingElement, existingExports);
-        reportDuplicateExportDecl(element, exports);
+        createDuplicateExportMessage(existingElement, existingExports);
+        createDuplicateExportMessage(element, exports);
+        createDuplicateExportDeclMessage(existingElement, existingExports);
+        createDuplicateExportDeclMessage(element, exports);
         element = exportScope[name] = new ErroneousElementX(
             MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
       }
     } else {
       exportScope[name] = element;
       exporters[element] = exports;
     }
+    if (error != null) {
+      compiler.reportError(error, infos);
+    }
     return element;
   }
 
   /**
    * Propagates the exported [element] to all library nodes that depend upon
    * this node. If the propagation updated any pending exports, [:true:] is
    * returned.
    */
   bool propagateElement(Element element) {
     bool change = false;
@@ skipping 42 matching lines @@
   /// export scope of [library].
   void checkLibraryDependency(DiagnosticListener listener,
                               LibraryDependency tag,
                               LibraryElement library) {
     if (tag == null || tag.combinators == null) return;
     for (Combinator combinator in tag.combinators) {
       for (Identifier identifier in combinator.identifiers) {
         String name = identifier.source;
         Element element = library.findExported(name);
         if (element == null) {
-          listener.reportHint(
+          listener.reportHintMessage(
               identifier,
               combinator.isHide
                   ? MessageKind.EMPTY_HIDE : MessageKind.EMPTY_SHOW,
               {'uri': library.canonicalUri,
                'name': name});
         }
       }
     }
   }
 
@@ skipping 247 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }