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

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

 // Copyright (c) 2015, 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.constructors;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
     GenerativeConstantConstructor,
     RedirectingGenerativeConstantConstructor;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticListener,
+    DiagnosticMessage;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../diagnostics/spannable.dart' show
     Spannable;
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     ConstructorElementX,
     ErroneousConstructorElementX,
@@ skipping 29 matching lines @@
   Link<Node> initializers;
   bool hasSuper = false;
   bool isValidAsConstant = true;
 
   bool get isConst => constructor.isConst;
 
   InitializerResolver(this.visitor, this.constructor, this.functionNode);
 
   ResolutionRegistry get registry => visitor.registry;
 
-  error(Node node, MessageKind kind, [arguments = const {}]) {
-    visitor.error(node, kind, arguments);
-  }
-
-  warning(Node node, MessageKind kind, [arguments = const {}]) {
-    visitor.warning(node, kind, arguments);
-  }
+  DiagnosticListener get listener => visitor.compiler;
 
   bool isFieldInitializer(SendSet node) {
     if (node.selector.asIdentifier() == null) return false;
     if (node.receiver == null) return true;
     if (node.receiver.asIdentifier() == null) return false;
     return node.receiver.asIdentifier().isThis();
   }
 
   reportDuplicateInitializerError(Element field, Node init, Node existing) {
-    visitor.compiler.reportError(
-        init,
-        MessageKind.DUPLICATE_INITIALIZER, {'fieldName': field.name});
-    visitor.compiler.reportInfo(
-        existing,
-        MessageKind.ALREADY_INITIALIZED, {'fieldName': field.name});
+    listener.reportError(
+        listener.createMessage(
+            init,
+            MessageKind.DUPLICATE_INITIALIZER,
+            {'fieldName': field.name}),
+        <DiagnosticMessage>[
+            listener.createMessage(
+                existing,
+                MessageKind.ALREADY_INITIALIZED,
+                {'fieldName': field.name}),
+        ]);
     isValidAsConstant = false;
   }
 
   void checkForDuplicateInitializers(FieldElementX field, Node init) {
     // [field] can be null if it could not be resolved.
     if (field == null) return;
     if (initialized.containsKey(field)) {
       reportDuplicateInitializerError(field, init, initialized[field]);
     } else if (field.isFinal) {
       field.parseNode(visitor.compiler);
       Expression initializer = field.initializer;
       if (initializer != null) {
         reportDuplicateInitializerError(field, init, initializer);
       }
     }
     initialized[field] = init;
   }
 
   void resolveFieldInitializer(SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final String name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     FieldElement field;
     if (isFieldInitializer(init)) {
       target = constructor.enclosingClass.lookupLocalMember(name);
       if (target == null) {
-        error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
+        listener.reportErrorMessage(
+            selector, MessageKind.CANNOT_RESOLVE, {'name': name});
         target = new ErroneousFieldElementX(
             selector.asIdentifier(), constructor.enclosingClass);
       } else if (target.kind != ElementKind.FIELD) {
-        error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
+        listener.reportErrorMessage(
+            selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
         target = new ErroneousFieldElementX(
             selector.asIdentifier(), constructor.enclosingClass);
       } else if (!target.isInstanceMember) {
-        error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
+        listener.reportErrorMessage(
+            selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       } else {
         field = target;
       }
     } else {
-      error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
+      listener.reportErrorMessage(
+          init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     registry.useElement(init, target);
     registry.registerStaticUse(target);
     checkForDuplicateInitializers(target, init);
     // Resolve initializing value.
     ResolutionResult result = visitor.visitInStaticContext(
         init.arguments.head,
         inConstantInitializer: isConst);
     if (isConst) {
       if (result.isConstant && field != null) {
         // TODO(johnniwinther): Report error if `result.constant` is `null`.
         fieldInitializers[field] = result.constant;
       } else {
         isValidAsConstant = false;
       }
     }
   }
 
   InterfaceType getSuperOrThisLookupTarget(Node diagnosticNode,
                                            {bool isSuperCall}) {
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (identical(constructor.enclosingClass, visitor.compiler.objectClass)) {
-        error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
+        listener.reportErrorMessage(
+            diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
         isValidAsConstant = false;
       } else {
         return constructor.enclosingClass.supertype;
       }
     }
     return constructor.enclosingClass.thisType;
   }
 
   ResolutionResult resolveSuperOrThisForSend(Send call) {
     // Resolve the selector and the arguments.
@@ skipping 90 matching lines @@
       String className,
       Selector constructorSelector) {
     if (lookedupConstructor == null ||
         !lookedupConstructor.isGenerativeConstructor) {
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
       MessageKind kind = isImplicitSuperCall
           ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
           : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
-      visitor.compiler.reportError(
+      listener.reportErrorMessage(
           diagnosticNode, kind, {'constructorName': fullConstructorName});
       isValidAsConstant = false;
     } else {
       lookedupConstructor.computeType(visitor.compiler);
       if (!call.signatureApplies(lookedupConstructor.functionSignature)) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
-        visitor.compiler.reportError(diagnosticNode, kind);
+        listener.reportErrorMessage(diagnosticNode, kind);
         isValidAsConstant = false;
       } else if (constructor.isConst
                  && !lookedupConstructor.isConst) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.CONST_CALLS_NON_CONST_FOR_IMPLICIT
                            : MessageKind.CONST_CALLS_NON_CONST;
-        visitor.compiler.reportError(diagnosticNode, kind);
+        listener.reportErrorMessage(diagnosticNode, kind);
         isValidAsConstant = false;
       }
     }
   }
 
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
   ConstructorElement resolveInitializers() {
@@ skipping 49 matching lines @@
       initializers = functionNode.initializers.nodes;
     }
     bool resolvedSuper = false;
     for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
       if (link.head.asSendSet() != null) {
         final SendSet init = link.head.asSendSet();
         resolveFieldInitializer(init);
       } else if (link.head.asSend() != null) {
         final Send call = link.head.asSend();
         if (call.argumentsNode == null) {
-          error(link.head, MessageKind.INVALID_INITIALIZER);
+          listener.reportErrorMessage(
+              link.head, MessageKind.INVALID_INITIALIZER);
           continue;
         }
         if (Initializers.isSuperConstructorCall(call)) {
           if (resolvedSuper) {
-            error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
+            listener.reportErrorMessage(
+                call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
           }
           ResolutionResult result = resolveSuperOrThisForSend(call);
           if (isConst) {
             if (result.isConstant) {
               constructorInvocation = result.constant;
             } else {
               isValidAsConstant = false;
             }
           }
           resolvedSuper = true;
         } else if (Initializers.isConstructorRedirect(call)) {
           // Check that there is no body (Language specification 7.5.1).  If the
           // constructor is also const, we already reported an error in
           // [resolveMethodElement].
           if (functionNode.hasBody() && !constructor.isConst) {
-            error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
+            listener.reportErrorMessage(
+                functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
           }
           // Check that there are no other initializers.
           if (!initializers.tail.isEmpty) {
-            error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
+            listener.reportErrorMessage(
+                call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
           } else {
             constructor.isRedirectingGenerative = true;
           }
           // Check that there are no field initializing parameters.
           FunctionSignature signature = constructor.functionSignature;
           signature.forEachParameter((ParameterElement parameter) {
             if (parameter.isInitializingFormal) {
               Node node = parameter.node;
-              error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
+              listener.reportErrorMessage(
+                  node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
               isValidAsConstant = false;
             }
           });
           ResolutionResult result = resolveSuperOrThisForSend(call);
           if (isConst) {
             if (result.isConstant) {
               constructorInvocation = result.constant;
             } else {
               isValidAsConstant = false;
             }
             if (isConst && isValidAsConstant) {
               constructor.constantConstructor =
                   new RedirectingGenerativeConstantConstructor(
                       defaultValues,
                       constructorInvocation);
             }
           }
           return result.element;
         } else {
-          visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
+          listener.reportErrorMessage(
+              call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
           return null;
         }
       } else {
-        error(link.head, MessageKind.INVALID_INITIALIZER);
+        listener.reportErrorMessage(
+            link.head, MessageKind.INVALID_INITIALIZER);
       }
     }
     if (!resolvedSuper) {
       constructorInvocation = resolveImplicitSuperConstructorSend();
     }
     if (isConst && isValidAsConstant) {
       constructor.constantConstructor = new GenerativeConstantConstructor(
           constructor.enclosingClass.thisType,
           defaultValues,
           fieldInitializers,
@@ skipping 26 matching lines @@
       MessageKind kind,
       Map arguments,
       {bool isError: false,
        bool missingConstructor: false}) {
     if (missingConstructor) {
       registry.registerThrowNoSuchMethod();
     } else {
       registry.registerThrowRuntimeError();
     }
     if (isError || inConstContext) {
-      compiler.reportError(diagnosticNode, kind, arguments);
+      compiler.reportErrorMessage(
+          diagnosticNode, kind, arguments);
     } else {
-      compiler.reportWarning(diagnosticNode, kind, arguments);
+      compiler.reportWarningMessage(
+          diagnosticNode, kind, arguments);
     }
     ErroneousElement error = new ErroneousConstructorElementX(
         kind, arguments, name, enclosing);
     if (type == null) {
       type = new MalformedType(error, null);
     }
     return new ConstructorResult(resultKind, error, type);
   }
 
   ConstructorResult resolveConstructor(
       InterfaceType type,
       Node diagnosticNode,
       String constructorName) {
     ClassElement cls = type.element;
     cls.ensureResolved(compiler);
     ConstructorElement constructor = findConstructor(
         resolver.enclosingElement.library, cls, constructorName);
     if (constructor == null) {
       String fullConstructorName =
           Elements.constructorNameForDiagnostics(cls.name, constructorName);
       return reportAndCreateErroneousConstructorElement(
           diagnosticNode,
           ConstructorResultKind.UNRESOLVED_CONSTRUCTOR, type,
           cls, constructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName},
           missingConstructor: true);
     } else if (inConstContext && !constructor.isConst) {
-      compiler.reportError(
+      compiler.reportErrorMessage(
           diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
       return new ConstructorResult(
           ConstructorResultKind.NON_CONSTANT, constructor, type);
     } else {
       if (constructor.isGenerativeConstructor) {
         if (cls.isAbstract) {
-          compiler.reportWarning(
+          compiler.reportWarningMessage(
               diagnosticNode, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
           registry.registerAbstractClassInstantiation();
           return new ConstructorResult(
               ConstructorResultKind.ABSTRACT, constructor, type);
         } else {
           return new ConstructorResult(
               ConstructorResultKind.GENERATIVE, constructor, type);
         }
       } else {
         assert(invariant(diagnosticNode, constructor.isFactoryConstructor,
@@ skipping 63 matching lines @@
     assert(invariant(node.receiver, receiver != null,
         message: 'No result returned for $node.receiver.'));
     if (receiver.kind != null) {
       assert(invariant(node, receiver.element.isErroneous,
           message: "Unexpected prefix result: $receiver."));
       // We have already found an error.
       return receiver;
     }
 
     Identifier name = node.selector.asIdentifier();
-    if (name == null) internalError(node.selector, 'unexpected node');
+    if (name == null) {
+      compiler.internalError(node.selector, 'unexpected node');
+    }
 
     if (receiver.type != null) {
       if (receiver.type.isInterfaceType) {
         return resolveConstructor(receiver.type, name, name.source);
       } else {
         // TODO(johnniwinther): Update the message for the different types.
         return reportAndCreateErroneousConstructorElement(
             name,
             ConstructorResultKind.INVALID_TYPE, null,
             resolver.enclosingElement, name.source,
             MessageKind.NOT_A_TYPE, {'node': name});
       }
     } else if (receiver.element.isPrefix) {
       PrefixElement prefix = receiver.element;
       Element member = prefix.lookupLocalMember(name.source);
       return constructorResultForElement(node, name.source, member);
     } else {
-      return internalError(node.receiver, 'unexpected receiver $receiver');
+      return compiler.internalError(
+          node.receiver, 'unexpected receiver $receiver');
     }
   }
 
   ConstructorResult visitIdentifier(Identifier node) {
     String name = node.source;
     Element element = resolver.reportLookupErrorIfAny(
         lookupInScope(compiler, node, resolver.scope, name), node, name);
     registry.useElement(node, element);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     return constructorResultForElement(node, name, element);
@@ skipping 71 matching lines @@
           resolver.enclosingElement, name,
           MessageKind.CANNOT_INSTANTIATE_TYPEDEF, {'typedefName': name});
     } else if (type.isTypeVariable) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE, type,
           resolver.enclosingElement, name,
           MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
           {'typeVariableName': name});
     }
-    internalError(node, "Unexpected constructor type $type");
-    return null;
+    return compiler.internalError(node, "Unexpected constructor type $type");
   }
 
 }
 
 enum ConstructorResultKind {
   GENERATIVE,
   FACTORY,
   ABSTRACT,
   INVALID_TYPE,
   UNRESOLVED_CONSTRUCTOR,
@@ skipping 44 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }