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

pkg/compiler/lib/src/mirrors_used.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 dart2js.mirrors_used;
 
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compile_time_constants.dart' show
     ConstantCompiler;
@@ skipping 391 matching lines @@
           StringConstantValue string = entry;
           result.add(string.primitiveValue.slowToString());
         } else if (!onlyStrings && entry.isType) {
           TypeConstantValue type = entry;
           result.add(type.representedType);
         } else {
           Spannable node = positionOf(entry);
           MessageKind kind = onlyStrings
               ? MessageKind.MIRRORS_EXPECTED_STRING
               : MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE;
-          compiler.reportHint(
-              node,
-              kind, {'name': node, 'type': apiTypeOf(entry)});
+          compiler.reportHintMessage(
+              node, kind, {'name': node, 'type': apiTypeOf(entry)});
         }
       }
       return result;
     } else if (!onlyStrings && constant.isType) {
       TypeConstantValue type = constant;
       return [type.representedType];
     } else if (constant.isString) {
       StringConstantValue string = constant;
       var iterable =
           string.primitiveValue.slowToString().split(',').map((e) => e.trim());
       return onlyStrings ? new List<String>.from(iterable) : iterable.toList();
     } else {
       Spannable node = positionOf(constant);
       MessageKind kind = onlyStrings
           ? MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST
           : MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST;
-      compiler.reportHint(
-          node,
-          kind, {'name': node, 'type': apiTypeOf(constant)});
+      compiler.reportHintMessage(
+          node, kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
   DartType apiTypeOf(ConstantValue constant) {
     DartType type = constant.getType(compiler.coreTypes);
     LibraryElement library = type.element.library;
     if (type.isInterfaceType && library.isInternalLibrary) {
       InterfaceType interface = type;
@@ skipping 62 matching lines @@
       }
     }
     return result;
   }
 
   /// Resolve [expression] in [enclosingLibrary]'s import scope.
   Element resolveExpression(String expression) {
     List<String> identifiers = expression.split('.');
     Element element = enclosingLibrary.find(identifiers[0]);
     if (element == null) {
-      compiler.reportHint(
-          spannable, MessageKind.MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY,
+      compiler.reportHintMessage(
+          spannable,
+          MessageKind.MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY,
           {'name': expression});
       return null;
     } else {
       if (identifiers.length == 1) return element;
       return resolveLocalExpression(element, identifiers.sublist(1));
     }
   }
 
   /// Resolve [identifiers] in [element]'s local members.
   Element resolveLocalExpression(Element element, List<String> identifiers) {
     Element current = element;
     for (String identifier in identifiers) {
       Element e = findLocalMemberIn(current, identifier);
       if (e == null) {
         if (current.isLibrary) {
           LibraryElement library = current;
-          compiler.reportHint(
+          compiler.reportHintMessage(
               spannable, MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
               {'name': identifiers[0],
                'library': library.libraryOrScriptName});
         } else {
-          compiler.reportHint(
+          compiler.reportHintMessage(
               spannable, MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
               {'name': identifier, 'element': current.name});
         }
         return current;
       }
       current = e;
     }
     return current;
   }
 
@@ skipping 35 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }