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

pkg/compiler/lib/src/resolution/signatures.dart

Index: pkg/compiler/lib/src/resolution/signatures.dart
diff --git a/pkg/compiler/lib/src/resolution/signatures.dart b/pkg/compiler/lib/src/resolution/signatures.dart
index 2a6aa6d4dbea9a1327d0f1279662ab2d6b4811ff..858f9b565cd0b636a334e8651445c9ce8209480d 100644
--- a/pkg/compiler/lib/src/resolution/signatures.dart
+++ b/pkg/compiler/lib/src/resolution/signatures.dart
@@ -66,7 +66,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
     // This must be a list of optional arguments.
     String value = node.beginToken.stringValue;
     if ((!identical(value, '[')) && (!identical(value, '{'))) {
-      internalError(node, "expected optional parameters");
+      compiler.internalError(node, "expected optional parameters");
     }
     optionalParametersAreNamed = (identical(value, '{'));
     isOptionalParameter = true;
@@ -78,26 +78,26 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
   FormalElementX visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
     if (definitions.isEmpty) {
-      internalError(node, 'no parameter definition');
+      compiler.internalError(node, 'no parameter definition');
       return null;
     }
     if (!definitions.tail.isEmpty) {
-      internalError(definitions.tail.head, 'extra definition');
+      compiler.internalError(definitions.tail.head, 'extra definition');
       return null;
     }
     Node definition = definitions.head;
     if (definition is NodeList) {
-      internalError(node, 'optional parameters are not implemented');
+      compiler.internalError(node, 'optional parameters are not implemented');
     }
     if (node.modifiers.isConst) {
-      compiler.reportError(node, MessageKind.FORMAL_DECLARED_CONST);
+      compiler.reportErrorMessage(node, MessageKind.FORMAL_DECLARED_CONST);
     }
     if (node.modifiers.isStatic) {
-      compiler.reportError(node, MessageKind.FORMAL_DECLARED_STATIC);
+      compiler.reportErrorMessage(node, MessageKind.FORMAL_DECLARED_STATIC);
     }
 
     if (currentDefinitions != null) {
-      internalError(node, 'function type parameters not supported');
+      compiler.internalError(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     FormalElementX element = definition.accept(this);
@@ -113,7 +113,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
     if (isOptionalParameter &&
         optionalParametersAreNamed &&
         Name.isPrivateName(node.source)) {
-      compiler.reportError(node, MessageKind.PRIVATE_NAMED_PARAMETER);
+      compiler.reportErrorMessage(node, MessageKind.PRIVATE_NAMED_PARAMETER);
     }
   }
 
@@ -172,7 +172,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
           functionExpression.name.asIdentifier() != null) {
         return functionExpression.name.asIdentifier();
       } else {
-        internalError(node,
+        compiler.internalError(node,
             'internal error: unimplemented receiver on parameter send');
         return null;
       }
@@ -205,12 +205,13 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
     InitializingFormalElementX element;
     Identifier receiver = node.receiver.asIdentifier();
     if (receiver == null || !receiver.isThis()) {
-      error(node, MessageKind.INVALID_PARAMETER);
+      compiler.reportErrorMessage(node, MessageKind.INVALID_PARAMETER);
       return new ErroneousInitializingFormalElementX(
           getParameterName(node), enclosingElement);
     } else {
       if (!enclosingElement.isGenerativeConstructor) {
-        error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
+        compiler.reportErrorMessage(
+            node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
         return new ErroneousInitializingFormalElementX(
             getParameterName(node), enclosingElement);
       }
@@ -220,11 +221,13 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
           enclosingElement.enclosingClass.lookupLocalMember(name.source);
       if (fieldElement == null ||
           !identical(fieldElement.kind, ElementKind.FIELD)) {
-        error(node, MessageKind.NOT_A_FIELD, {'fieldName': name});
+        compiler.reportErrorMessage(
+            node, MessageKind.NOT_A_FIELD, {'fieldName': name});
         fieldElement = new ErroneousFieldElementX(
             name, enclosingElement.enclosingClass);
       } else if (!fieldElement.isInstanceMember) {
-        error(node, MessageKind.NOT_INSTANCE_FIELD, {'fieldName': name});
+        compiler.reportErrorMessage(
+            node, MessageKind.NOT_INSTANCE_FIELD, {'fieldName': name});
         fieldElement = new ErroneousFieldElementX(
             name, enclosingElement.enclosingClass);
       }
@@ -247,7 +250,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
-      compiler.reportError(defaultValue, defaultValuesError);
+      compiler.reportErrorMessage(defaultValue, defaultValuesError);
     }
     return element;
   }
@@ -256,11 +259,13 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
     // This is a function typed parameter.
     Modifiers modifiers = currentDefinitions.modifiers;
     if (modifiers.isFinal) {
-      compiler.reportError(modifiers,
+      compiler.reportErrorMessage(
+          modifiers,
           MessageKind.FINAL_FUNCTION_TYPE_PARAMETER);
     }
     if (modifiers.isVar) {
-      compiler.reportError(modifiers, MessageKind.VAR_FUNCTION_TYPE_PARAMETER);
+      compiler.reportErrorMessage(
+          modifiers, MessageKind.VAR_FUNCTION_TYPE_PARAMETER);
     }
 
     return createParameter(node.name, null);
@@ -276,7 +281,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty || (link.head is !NodeList)) {
-          internalError(link.head, "expected optional parameters");
+          compiler.internalError(link.head, "expected optional parameters");
         }
       }
     }
@@ -315,7 +320,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
           // parse. So we suppress the message about missing formals.
           assert(invariant(element, compiler.compilationFailed));
         } else {
-          compiler.reportError(element, MessageKind.MISSING_FORMALS);
+          compiler.reportErrorMessage(element, MessageKind.MISSING_FORMALS);
         }
       }
     } else {
@@ -323,8 +328,9 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
         if (!identical(formalParameters.endToken.next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
-          compiler.reportError(formalParameters,
-                               MessageKind.EXTRA_FORMALS);
+          compiler.reportErrorMessage(
+              formalParameters,
+              MessageKind.EXTRA_FORMALS);
         }
       }
       LinkBuilder<Element> parametersBuilder =
@@ -368,8 +374,9 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
-        compiler.reportError(formalParameters,
-                                 MessageKind.ILLEGAL_SETTER_FORMALS);
+        compiler.reportErrorMessage(
+            formalParameters,
+            MessageKind.ILLEGAL_SETTER_FORMALS);
       }
     }
     LinkBuilder<DartType> parameterTypes = new LinkBuilder<DartType>();
@@ -426,7 +433,7 @@ class SignatureResolver extends MappingVisitor<FormalElementX> {
   DartType resolveTypeAnnotation(TypeAnnotation annotation) {
     DartType type = resolveReturnType(annotation);
     if (type.isVoid) {
-      compiler.reportError(annotation, MessageKind.VOID_NOT_ALLOWED);
+      compiler.reportErrorMessage(annotation, MessageKind.VOID_NOT_ALLOWED);
     }
     return type;
   }