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

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import '../compiler.dart' show
     Compiler;
 import '../constants/constant_constructors.dart';
 import '../constants/constructors.dart';
@@ skipping 233 matching lines @@
   // Marks this element as a native element.
   void setNative(String name) {
     _isNative = true;
     _fixedBackendName = name;
   }
 
   FunctionElement asFunctionElement() => null;
 
   bool get isAbstract => modifiers.isAbstract;
 
-  void diagnose(Element context, DiagnosticListener listener) {}
-
   bool get hasTreeElements => analyzableElement.hasTreeElements;
 
   TreeElements get treeElements => analyzableElement.treeElements;
 
   AnalyzableElement get analyzableElement {
     Element element = outermostEnclosingMemberOrTopLevel;
     if (element.isAbstractField || element.isPrefix) return element.library;
     return element;
   }
 
@@ skipping 202 matching lines @@
   WarnOnUseElementX(WrappedMessage this.warning, WrappedMessage this.info,
                     Element enclosingElement, Element wrappedElement)
       : this.wrappedElement = wrappedElement,
         super(wrappedElement.name, ElementKind.WARN_ON_USE, enclosingElement);
 
   Element unwrap(DiagnosticListener listener, Spannable usageSpannable) {
     var unwrapped = wrappedElement;
     if (warning != null) {
       Spannable spannable = warning.spannable;
       if (spannable == null) spannable = usageSpannable;
-      listener.reportWarning(
+      DiagnosticMessage warningMessage = listener.createMessage(
           spannable, warning.messageKind, warning.messageArguments);
-    }
-    if (info != null) {
-      Spannable spannable = info.spannable;
-      if (spannable == null) spannable = usageSpannable;
-      listener.reportInfo(
-          spannable, info.messageKind, info.messageArguments);
+      List<DiagnosticMessage> infos = <DiagnosticMessage>[];
+      if (info != null) {
+        Spannable spannable = info.spannable;
+        if (spannable == null) spannable = usageSpannable;
+        infos.add(listener.createMessage(
+            spannable, info.messageKind, info.messageArguments));
+      }
+      listener.reportWarning(warningMessage, infos);
     }
     if (unwrapped.isWarnOnUse) {
       unwrapped = unwrapped.unwrap(listener, usageSpannable);
     }
     return unwrapped;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitWarnOnUseElement(this, arg);
   }
@@ skipping 31 matching lines @@
     var set = new Setlet();
     while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
   }
 
+  List<DiagnosticMessage> computeInfos(Element context,
+                                   DiagnosticListener listener) {
+    return const <DiagnosticMessage>[];
+  }
+
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAmbiguousElement(this, arg);
   }
 
   bool get isTopLevel => false;
 
   DynamicType get type => const DynamicType();
 }
 
 /// Element synthesized to diagnose an ambiguous import.
 class AmbiguousImportX extends AmbiguousElementX {
   AmbiguousImportX(
       MessageKind messageKind,
       Map messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : super(messageKind, messageArguments, enclosingElement, existingElement,
               newElement);
 
-  void diagnose(Element context, DiagnosticListener listener) {
+  List<DiagnosticMessage> computeInfos(
+      Element context,
+      DiagnosticListener listener) {
+    List<DiagnosticMessage> infos = <DiagnosticMessage>[];
     Setlet ambiguousElements = flatten();
     MessageKind code = (ambiguousElements.length == 1)
         ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
     LibraryElementX importer = context.library;
     for (Element element in ambiguousElements) {
-      var arguments = {'name': element.name};
-      listener.reportInfo(element, code, arguments);
+      Map arguments = {'name': element.name};
+      infos.add(listener.createMessage(element, code, arguments));
       listener.withCurrentElement(importer, () {
         for (ImportElement import in importer.importers.getImports(element)) {
-          listener.reportInfo(
-              import, MessageKind.IMPORTED_HERE, arguments);
+          infos.add(listener.createMessage(
+              import, MessageKind.IMPORTED_HERE, arguments));
         }
       });
     }
+    return infos;
   }
 }
 
 /// Element synthesized to recover from a duplicated member of an element.
 class DuplicatedElementX extends AmbiguousElementX {
   DuplicatedElementX(
       MessageKind messageKind,
       Map messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : super(messageKind, messageArguments, enclosingElement, existingElement,
@@ skipping 13 matching lines @@
   }
 
   void add(Element element, DiagnosticListener listener) {
     String name = element.name;
     if (element.isAccessor) {
       addAccessor(element, contents[name], listener);
     } else {
       Element existing = contents.putIfAbsent(name, () => element);
       if (!identical(existing, element)) {
         listener.reportError(
-            element, MessageKind.DUPLICATE_DEFINITION, {'name': name});
-        listener.reportInfo(existing,
-            MessageKind.EXISTING_DEFINITION, {'name': name});
+            listener.createMessage(
+                element,
+                MessageKind.DUPLICATE_DEFINITION,
+                {'name': name}),
+            <DiagnosticMessage>[
+                listener.createMessage(
+                    existing,
+                    MessageKind.EXISTING_DEFINITION,
+                    {'name': name}),
+            ]);
       }
     }
   }
 
   /**
    * Adds a definition for an [accessor] (getter or setter) to a scope.
    * The definition binds to an abstract field that can hold both a getter
    * and a setter.
    *
    * The abstract field is added once, for the first getter or setter, and
    * reused if the other one is also added.
    * The abstract field should not be treated as a proper member of the
    * container, it's simply a way to return two results for one lookup.
    * That is, the getter or setter does not have the abstract field as enclosing
    * element, they are enclosed by the class or compilation unit, as is the
    * abstract field.
    */
   void addAccessor(AccessorElementX accessor,
                    Element existing,
                    DiagnosticListener listener) {
     void reportError(Element other) {
-      listener.reportError(accessor,
-                           MessageKind.DUPLICATE_DEFINITION,
-                           {'name': accessor.name});
-      listener.reportInfo(
-          other, MessageKind.EXISTING_DEFINITION, {'name': accessor.name});
+      listener.reportError(
+          listener.createMessage(
+              accessor,
+              MessageKind.DUPLICATE_DEFINITION,
+              {'name': accessor.name}),
+          <DiagnosticMessage>[
+              listener.createMessage(
+                  other,
+                  MessageKind.EXISTING_DEFINITION,
+                  {'name': accessor.name}),
+          ]);
 
       contents[accessor.name] = new DuplicatedElementX(
           MessageKind.DUPLICATE_DEFINITION, {'name': accessor.name},
           accessor.memberContext.enclosingElement, other, accessor);
     }
 
     if (existing != null) {
       if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
         reportError(existing);
         return;
@@ skipping 73 matching lines @@
       implementationLibrary.addMember(element, listener);
     } else {
       library.addMember(element, listener);
     }
   }
 
   void setPartOf(PartOf tag, DiagnosticListener listener) {
     LibraryElementX library = enclosingElement;
     if (library.entryCompilationUnit == this) {
       partTag = tag;
-      listener.reportError(tag, MessageKind.IMPORT_PART_OF);
+      listener.reportErrorMessage(
+          tag, MessageKind.IMPORT_PART_OF);
       return;
     }
     if (!localMembers.isEmpty) {
-      listener.reportError(tag, MessageKind.BEFORE_TOP_LEVEL);
+      listener.reportErrorMessage(
+          tag, MessageKind.BEFORE_TOP_LEVEL);
       return;
     }
     if (partTag != null) {
-      listener.reportWarning(tag, MessageKind.DUPLICATED_PART_OF);
+      listener.reportWarningMessage(tag, MessageKind.DUPLICATED_PART_OF);
       return;
     }
     partTag = tag;
     LibraryName libraryTag = library.libraryTag;
     String actualName = tag.name.toString();
     if (libraryTag != null) {
       String expectedName = libraryTag.name.toString();
       if (expectedName != actualName) {
-        listener.reportWarning(tag.name,
+        listener.reportWarningMessage(
+            tag.name,
             MessageKind.LIBRARY_NAME_MISMATCH,
             {'libraryName': expectedName});
       }
     } else {
-      listener.reportWarning(library,
-          MessageKind.MISSING_LIBRARY_NAME,
-          {'libraryName': actualName});
-      listener.reportInfo(tag.name,
-          MessageKind.THIS_IS_THE_PART_OF_TAG);
+      listener.reportWarning(
+          listener.createMessage(
+              library,
+              MessageKind.MISSING_LIBRARY_NAME,
+              {'libraryName': actualName}),
+          <DiagnosticMessage>[
+              listener.createMessage(
+                  tag.name,
+                  MessageKind.THIS_IS_THE_PART_OF_TAG),
+          ]);
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   Element get analyzableElement => library;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
@@ skipping 1854 matching lines @@
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembersCache = null;
     localMembersReversed = localMembersReversed.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     if (element.isField && element.name == name) {
-      listener.reportError(element, MessageKind.MEMBER_USES_CLASS_NAME);
+      listener.reportErrorMessage(
+          element, MessageKind.MEMBER_USES_CLASS_NAME);
     }
     localScope.add(element, listener);
   }
 
   Element localLookup(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       result = origin.localLookup(elementName);
     }
     return result;
@@ skipping 433 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }