Update dart2js diagnostics to prepare for filtering.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 339 matching lines @@
       if (originParameterText != patchParameterText
           // We special case the list constructor because of the
           // optional parameter.
           && origin != compiler.unnamedListConstructor) {
         compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_MISMATCH,
             {'methodName': origin.name,
              'originParameter': originParameterText,
              'patchParameter': patchParameterText});
-        compiler.reportMessage(
-            compiler.spanFromSpannable(patchParameter),
-            MessageKind.PATCH_POINT_TO_PARAMETER.error(
-                {'parameterName': patchParameter.name}),
-            Diagnostic.INFO);
+        compiler.reportInfo(patchParameter,
+            MessageKind.PATCH_POINT_TO_PARAMETER,
+            {'parameterName': patchParameter.name});
       }
       DartType originParameterType = originParameter.computeType(compiler);
       DartType patchParameterType = patchParameter.computeType(compiler);
       if (originParameterType != patchParameterType) {
         compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_TYPE_MISMATCH,
             {'methodName': origin.name,
              'parameterName': originParameter.name,
              'originParameterType': originParameterType,
              'patchParameterType': patchParameterType});
-        compiler.reportMessage(
-            compiler.spanFromSpannable(patchParameter),
-            MessageKind.PATCH_POINT_TO_PARAMETER.error(
-                {'parameterName': patchParameter.name}),
-            Diagnostic.INFO);
+        compiler.reportInfo(patchParameter,
+            MessageKind.PATCH_POINT_TO_PARAMETER,
+            {'parameterName': patchParameter.name});
       }
 
       originParameters = originParameters.tail;
       patchParameters = patchParameters.tail;
     }
   }
 
   void checkMatchingPatchSignatures(FunctionElement origin,
                                     FunctionElement patch) {
     // TODO(johnniwinther): Show both origin and patch locations on errors.
@@ skipping 1154 matching lines @@
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Spannable node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportFatalError(node, kind, arguments);
   }
 
-  void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
-    ResolutionWarning message =
-        new ResolutionWarning(kind, arguments, compiler.terseDiagnostics);
-    compiler.reportWarning(node, message);
+  void warning(Spannable node, MessageKind kind, [Map arguments = const {}]) {
+    compiler.reportWarning(node, kind, arguments);
   }
 
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
   }
 
@@ skipping 267 matching lines @@
   }
 
   /// Checks the type arguments of [type] against the type variable bounds.
   void checkTypeVariableBounds(TreeElements elements,
                                TypeAnnotation node, GenericType type) {
     void checkTypeVariableBound(_, DartType typeArgument,
                                    TypeVariableType typeVariable,
                                    DartType bound) {
       compiler.backend.registerTypeVariableBoundCheck(elements);
       if (!compiler.types.isSubtype(typeArgument, bound)) {
-        compiler.reportWarningCode(node,
+        compiler.reportWarning(node,
             MessageKind.INVALID_TYPE_VARIABLE_BOUND,
             {'typeVariable': typeVariable,
              'bound': bound,
              'typeArgument': typeArgument,
              'thisType': type.element.thisType});
       }
     };
 
     compiler.types.checkTypeVariableBounds(type, checkTypeVariableBound);
   }
@@ skipping 74 matching lines @@
       if (existing != element) {
         reportDuplicateDefinition(node, element, existing);
       }
     }
     return element;
   }
 
   void reportDuplicateDefinition(/*Node|String*/ name,
                                  Spannable definition,
                                  Spannable existing) {
-    compiler.reportError(
-        definition,
+    compiler.reportError(definition,
         MessageKind.DUPLICATE_DEFINITION, {'name': name});
-    compiler.reportMessage(
-        compiler.spanFromSpannable(existing),
-        MessageKind.EXISTING_DEFINITION.error({'name': name}),
-        Diagnostic.INFO);
+    compiler.reportInfo(existing,
+        MessageKind.EXISTING_DEFINITION, {'name': name});
   }
 }
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
  * except for testing.
  */
 class ResolverVisitor extends MappingVisitor<Element> {
@@ skipping 141 matching lines @@
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  String name,
                                                  DualKind kind,
                                                  [Map arguments = const {}]) {
-    ResolutionWarning warning = new ResolutionWarning(
-        kind.warning, arguments, compiler.terseDiagnostics);
-    compiler.reportWarning(node, warning);
+    compiler.reportWarning(node, kind.warning, arguments);
     return new ErroneousElementX(kind.error, arguments, name, enclosingElement);
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return null;
     } else if (node.isSuper()) {
@@ skipping 1355 matching lines @@
           compiler.reportError(
               label,
               MessageKind.DUPLICATE_LABEL.error, {'labelName': labelName});
           compiler.reportInfo(
               existingElement.label,
               MessageKind.EXISTING_LABEL, {'labelName': labelName});
         } else {
           // It's only a warning if it shadows another label.
           existingElement = statementScope.lookupLabel(labelName);
           if (existingElement != null) {
-            compiler.reportWarningCode(
+            compiler.reportWarning(
                 label,
                 MessageKind.DUPLICATE_LABEL.warning, {'labelName': labelName});
             compiler.reportInfo(
                 existingElement.label,
                 MessageKind.EXISTING_LABEL, {'labelName': labelName});
           }
         }
 
         TargetElement targetElement = getOrCreateTargetElement(switchCase);
         LabelElement labelElement = targetElement.addLabel(label, labelName);
@@ skipping 423 matching lines @@
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     invariant(node, element != null);
     invariant(element, element.resolutionState == STATE_STARTED,
         message: () => 'cyclic resolution of class $element');
 
     if (identical(node.classKeyword.stringValue, 'typedef')) {
       // TODO(aprelev@gmail.com): Remove this deprecation diagnostic
       // together with corresponding TODO in parser.dart.
-      compiler.reportWarningCode(node.classKeyword,
+      compiler.reportWarning(node.classKeyword,
           MessageKind.DEPRECATED_TYPEDEF_MIXIN_SYNTAX);
     }
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
     DartType supertype = resolveSupertype(element, node.superclass);
@@ skipping 438 matching lines @@
                                String targetName, DualKind kind,
                                Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
       compiler.backend.registerThrowNoSuchMethod(resolver.mapping);
     } else {
       compiler.backend.registerThrowRuntimeError(resolver.mapping);
     }
     if (inConstContext) {
       compiler.reportError(diagnosticNode, kind.error, arguments);
     } else {
-      ResolutionWarning warning  =
-          new ResolutionWarning(
-              kind.warning, arguments, compiler.terseDiagnostics);
-      compiler.reportWarning(diagnosticNode, warning);
+      compiler.reportWarning(diagnosticNode, kind.warning, arguments);
     }
     return new ErroneousElementX(
         kind.error, arguments, targetName, enclosing);
   }
 
   Selector createConstructorSelector(String constructorName) {
     return constructorName == ''
         ? new Selector.callDefaultConstructor(
             resolver.enclosingElement.getLibrary())
         : new Selector.callConstructor(
@@ skipping 133 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }