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

pkg/compiler/lib/src/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 282 matching lines @@
     } else {
       compilationUnitElement.addMember(patch, listener);
     }
   }
 }
 
 void patchElement(Compiler compiler,
                   Element origin,
                   Element patch) {
   if (origin == null) {
-    compiler.reportError(
+    compiler.reportErrorMessage(
         patch, MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
   if (!(origin.isClass ||
         origin.isConstructor ||
         origin.isFunction ||
         origin.isAbstractField)) {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
-    compiler.reportError(origin, MessageKind.PATCH_NONPATCHABLE);
+    compiler.reportErrorMessage(origin, MessageKind.PATCH_NONPATCHABLE);
     return;
   }
   if (patch.isClass) {
     tryPatchClass(compiler, origin, patch);
   } else if (patch.isGetter) {
     tryPatchGetter(compiler, origin, patch);
   } else if (patch.isSetter) {
     tryPatchSetter(compiler, origin, patch);
   } else if (patch.isConstructor) {
     tryPatchConstructor(compiler, origin, patch);
   } else if(patch.isFunction) {
     tryPatchFunction(compiler, origin, patch);
   } else {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
-    compiler.reportError(patch, MessageKind.PATCH_NONPATCHABLE);
+    compiler.reportErrorMessage(patch, MessageKind.PATCH_NONPATCHABLE);
   }
 }
 
 void tryPatchClass(Compiler compiler,
                    Element origin,
                    ClassElement patch) {
   if (!origin.isClass) {
     compiler.reportError(
-        origin, MessageKind.PATCH_NON_CLASS, {'className': patch.name});
-    compiler.reportInfo(
-        patch, MessageKind.PATCH_POINT_TO_CLASS, {'className': patch.name});
+        compiler.createMessage(
+            origin,
+            MessageKind.PATCH_NON_CLASS,
+            {'className': patch.name}),
+        <DiagnosticMessage>[
+            compiler.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_CLASS,
+                {'className': patch.name}),
+        ]);
     return;
   }
   patchClass(compiler, origin, patch);
 }
 
 void patchClass(Compiler compiler,
                 ClassElementX origin,
                 ClassElementX patch) {
   if (origin.isPatched) {
     compiler.internalError(origin,
@@ skipping 134 matching lines @@
     }
   }
 }
 
 
 void tryPatchGetter(DiagnosticListener listener,
                     Element origin,
                     FunctionElement patch) {
   if (!origin.isAbstractField) {
     listener.reportError(
-        origin, MessageKind.PATCH_NON_GETTER, {'name': origin.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NON_GETTER,
+            {'name': origin.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_GETTER,
+                {'getterName': patch.name}),
+        ]);
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.getter == null) {
     listener.reportError(
-        origin, MessageKind.PATCH_NO_GETTER, {'getterName': patch.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NO_GETTER,
+            {'getterName': patch.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_GETTER,
+                {'getterName': patch.name}),
+        ]);
     return;
   }
   GetterElementX getter = originField.getter;
   patchFunction(listener, getter, patch);
 }
 
 void tryPatchSetter(DiagnosticListener listener,
                     Element origin,
                     FunctionElement patch) {
   if (!origin.isAbstractField) {
     listener.reportError(
-        origin, MessageKind.PATCH_NON_SETTER, {'name': origin.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NON_SETTER,
+            {'name': origin.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_SETTER,
+                {'setterName': patch.name}),
+        ]);
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.setter == null) {
     listener.reportError(
-        origin, MessageKind.PATCH_NO_SETTER, {'setterName': patch.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NO_SETTER,
+            {'setterName': patch.name}),
+        <DiagnosticMessage>[
+              listener.createMessage(
+                  patch,
+                  MessageKind.PATCH_POINT_TO_SETTER,
+                  {'setterName': patch.name}),
+        ]);
     return;
   }
   SetterElementX setter = originField.setter;
   patchFunction(listener, setter, patch);
 }
 
 void tryPatchConstructor(DiagnosticListener listener,
                          Element origin,
                          FunctionElement patch) {
   if (!origin.isConstructor) {
     listener.reportError(
-        origin,
-        MessageKind.PATCH_NON_CONSTRUCTOR, {'constructorName': patch.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
-        {'constructorName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NON_CONSTRUCTOR,
+            {'constructorName': patch.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
+                {'constructorName': patch.name}),
+        ]);
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void tryPatchFunction(DiagnosticListener listener,
                       Element origin,
                       FunctionElement patch) {
   if (!origin.isFunction) {
     listener.reportError(
-        origin,
-        MessageKind.PATCH_NON_FUNCTION, {'functionName': patch.name});
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
+        listener.createMessage(
+            origin,
+            MessageKind.PATCH_NON_FUNCTION,
+            {'functionName': patch.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                patch,
+                MessageKind.PATCH_POINT_TO_FUNCTION,
+                {'functionName': patch.name}),
+        ]);
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void patchFunction(DiagnosticListener listener,
                    BaseFunctionElementX origin,
                    BaseFunctionElementX patch) {
   if (!origin.modifiers.isExternal) {
-    listener.reportError(origin, MessageKind.PATCH_NON_EXTERNAL);
-    listener.reportInfo(
-        patch,
-        MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
+    listener.reportError(
+        listener.createMessage(origin, MessageKind.PATCH_NON_EXTERNAL),
+        <DiagnosticMessage>[
+              listener.createMessage(
+                  patch,
+                  MessageKind.PATCH_POINT_TO_FUNCTION,
+                  {'functionName': patch.name}),
+        ]);
     return;
   }
   if (origin.isPatched) {
     listener.internalError(origin,
         "Trying to patch a function more than once.");
   }
   origin.applyPatch(patch);
 }
 
 PatchVersion getPatchVersion(Compiler compiler, Element element) {
   return EagerAnnotationHandler.checkAnnotation(compiler, element,
       const PatchAnnotationHandler());
 }
 
 class PatchVersion {
   final String tag;
 
   const PatchVersion(this.tag);
 
   bool isActive(String patchTag) => tag == null || tag == patchTag;
 
   String toString() => 'PatchVersion($tag)';
 }