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

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

 // Copyright (c) 2014, 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.resolution.signatures;
 
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart';
 import '../diagnostics/invariant.dart' show
@@ skipping 48 matching lines @@
         this.resolver =
             new ResolverVisitor(compiler, enclosingElement, registry),
         super(compiler, registry);
 
   bool get defaultValuesAllowed => defaultValuesError == null;
 
   visitNodeList(NodeList node) {
     // 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;
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
     optionalParameters = elements.toList();
   }
 
   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);
     if (currentDefinitions.metadata != null) {
       element.metadataInternal =
           compiler.resolver.resolveMetadata(element, node);
     }
     currentDefinitions = null;
     return element;
   }
 
   void validateName(Identifier node) {
     if (isOptionalParameter &&
         optionalParametersAreNamed &&
         Name.isPrivateName(node.source)) {
-      compiler.reportError(node, MessageKind.PRIVATE_NAMED_PARAMETER);
+      compiler.reportErrorMessage(node, MessageKind.PRIVATE_NAMED_PARAMETER);
     }
   }
 
   void computeParameterType(FormalElementX element,
                             [VariableElement fieldElement]) {
     void computeFunctionType(FunctionExpression functionExpression) {
       FunctionSignature functionSignature = SignatureResolver.analyze(
           compiler, functionExpression.parameters,
           functionExpression.returnType, element, registry,
           defaultValuesError: MessageKind.FUNCTION_TYPE_FORMAL_WITH_DEFAULT);
@@ skipping 38 matching lines @@
     if (identifier != null) {
       // Normal parameter: [:Type name:].
       return identifier;
     } else {
       // Function type parameter: [:void name(DartType arg):].
       var functionExpression = node.selector.asFunctionExpression();
       if (functionExpression != null &&
           functionExpression.name.asIdentifier() != null) {
         return functionExpression.name.asIdentifier();
       } else {
-        internalError(node,
+        compiler.internalError(node,
             'internal error: unimplemented receiver on parameter send');
         return null;
       }
     }
   }
 
   // The only valid [Send] can be in constructors and must be of the form
   // [:this.x:] (where [:x:] represents an instance field).
   InitializingFormalElementX visitSend(Send node) {
     return createFieldParameter(node, null);
@@ skipping 12 matching lines @@
     }
     computeParameterType(parameter);
     return parameter;
   }
 
   InitializingFormalElementX createFieldParameter(Send node,
                                                   Expression initializer) {
     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);
       }
       Identifier name = getParameterName(node);
       validateName(name);
       Element fieldElement =
           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);
       }
       element = new InitializingFormalElementX(enclosingElement,
           currentDefinitions, name, initializer, fieldElement,
           isOptional: isOptionalParameter, isNamed: optionalParametersAreNamed);
       computeParameterType(element, fieldElement);
     }
     return element;
   }
 
   /// A [SendSet] node is an optional parameter with a default value.
   Element visitSendSet(SendSet node) {
     FormalElementX element;
     if (node.receiver != null) {
       element = createFieldParameter(node, node.arguments.first);
     } else if (node.selector.asIdentifier() != null ||
                node.selector.asFunctionExpression() != null) {
       element = createParameter(getParameterName(node), node.arguments.first);
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
-      compiler.reportError(defaultValue, defaultValuesError);
+      compiler.reportErrorMessage(defaultValue, defaultValuesError);
     }
     return element;
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
     // 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);
   }
 
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
     for (; !link.isEmpty; link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // 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");
         }
       }
     }
     return elements;
   }
 
   /**
    * Resolves formal parameters and return type of a [FunctionExpression]
    * to a [FunctionSignature].
    *
@@ skipping 18 matching lines @@
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter) {
         if (element.isErroneous) {
           // If the element is erroneous, an error should already have been
           // reported. In the case of parse errors, it is possible that there
           // are formal parameters, but something else in the method failed to
           // 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 {
       if (element.isGetter) {
         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 =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toList();
     }
     DartType returnType;
     if (element.isFactoryConstructor) {
       returnType = element.enclosingClass.thisType;
@@ skipping 23 matching lines @@
       case AsyncMarker.ASYNC_STAR:
         returnType = compiler.coreTypes.streamType();
         break;
       }
     }
 
     if (element.isSetter && (requiredParameterCount != 1 ||
                                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>();
     for (FormalElement parameter in parameters) {
        parameterTypes.addLast(parameter.type);
     }
     List<DartType> optionalParameterTypes = const <DartType>[];
     List<String> namedParameters = const <String>[];
     List<DartType> namedParameterTypes = const <DartType>[];
     List<Element> orderedOptionalParameters =
@@ skipping 36 matching lines @@
         requiredParameterCount: requiredParameterCount,
         optionalParameterCount: visitor.optionalParameterCount,
         optionalParametersAreNamed: visitor.optionalParametersAreNamed,
         orderedOptionalParameters: orderedOptionalParameters,
         type: type);
   }
 
   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;
   }
 
   DartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return const DynamicType();
     DartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return const DynamicType();
     }
     return result;
   }
 }