Update dart2js diagnostics to prepare for filtering.

sdk/lib/_internal/compiler/implementation/resolution/class_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.
 
 library resolution.compute_members;
 
 import '../elements/elements.dart'
     show Element,
          Name,
          PublicName,
@@ skipping 203 matching lines @@
           for (MemberSignature other in inheritedMembers) {
             if (!compiler.types.isSubtype(inherited.functionType,
                                           other.functionType)) {
               continue outer;
             }
           }
           subtypesOfAllInherited.putIfAbsent(inherited.functionType,
               () => new Set<Member>()).add(inherited);
         }
         if (someAreGetters && !allAreGetters) {
-          compiler.reportWarningCode(cls,
-                                     MessageKind.INHERIT_GETTER_AND_METHOD,
-                                     {'class': thisType, 'name': name.text });
+          compiler.reportWarning(cls,
+                                 MessageKind.INHERIT_GETTER_AND_METHOD,
+                                 {'class': thisType, 'name': name.text });
           for (Member inherited in inheritedMembers) {
             MessageKind kind;
             if (inherited.isMethod) {
               kind = MessageKind.INHERITED_METHOD;
             } else {
               assert(invariant(cls, inherited.isGetter,
                   message: 'Conflicting member is neither a method nor a '
                            'getter.'));
               if (inherited.isDeclaredByField) {
                 kind = MessageKind.INHERITED_IMPLICIT_GETTER;
@@ skipping 113 matching lines @@
           interfaceMember.declarer.element == cls) {
         // Abstract method declared in [cls].
         MessageKind kind = MessageKind.ABSTRACT_METHOD;
         if (interfaceMember.isSetter) {
           kind = MessageKind.ABSTRACT_SETTER;
         } else if (interfaceMember.isGetter) {
           kind = MessageKind.ABSTRACT_GETTER;
         }
         reportMessage(
             interfaceMember.element, MessageKind.ABSTRACT_METHOD, () {
-          compiler.reportWarningCode(
+          compiler.reportWarning(
               interfaceMember.element, kind,
               {'class': cls.name, 'name': name.text});
         });
       } else {
          reportWarning(MessageKind singleKind,
                        MessageKind multipleKind,
                        MessageKind explicitlyDeclaredKind,
                        [MessageKind implicitlyDeclaredKind]) {
           Member inherited = interfaceMember.declarations.first;
           reportMessage(
               interfaceMember, MessageKind.UNIMPLEMENTED_METHOD, () {
-            compiler.reportWarningCode(cls,
+            compiler.reportWarning(cls,
                 interfaceMember.declarations.length == 1
                     ? singleKind : multipleKind,
                 {'class': cls.name,
                  'name': name.text,
                  'method': interfaceMember,
                  'declarer': inherited.declarer});
             for (Member inherited in interfaceMember.declarations) {
               compiler.reportInfo(inherited.element,
                   inherited.isDeclaredByField ?
                       implicitlyDeclaredKind : explicitlyDeclaredKind,
@@ skipping 28 matching lines @@
     if (superMember == null) {
       // No override.
       if (!declared.isStatic) {
         ClassElement superclass = cls.superclass;
         while (superclass != null) {
           Member superMember =
               superclass.lookupClassMember(declared.name);
           if (superMember != null && superMember.isStatic) {
             reportMessage(superMember, MessageKind.INSTANCE_STATIC_SAME_NAME,
                 () {
-              compiler.reportWarningCode(
+              compiler.reportWarning(
                   declared.element,
                   MessageKind.INSTANCE_STATIC_SAME_NAME,
                   {'memberName': declared.name,
                     'className': superclass.name});
               compiler.reportInfo(superMember.element,
                   MessageKind.INSTANCE_STATIC_SAME_NAME_CONT);
             });
             break;
           }
           superclass = superclass.superclass;
@@ skipping 40 matching lines @@
         } else if (declared.isMethod && inherited.isGetter) {
           reportError(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD,
                       MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT);
         } else {
           DartType inheritedType = inherited.functionType;
           if (!compiler.types.isSubtype(declaredType, inheritedType)) {
             void reportWarning(var marker,
                                MessageKind warningKind,
                                MessageKind infoKind) {
               reportMessage(marker, MessageKind.INVALID_OVERRIDE_METHOD, () {
-                compiler.reportWarningCode(declared.element, warningKind,
+                compiler.reportWarning(declared.element, warningKind,
                     {'declaredType': declared.type,
                      'name': declared.name.text,
                      'class': cls.thisType,
                      'inheritedType': inherited.type,
                      'inheritedClass': inherited.declarer});
                 compiler.reportInfo(inherited.element, infoKind,
                     {'name': declared.name.text,
                      'class': inherited.declarer});
               });
             }
@@ skipping 55 matching lines @@
   }
 
   static void computeClassMembers(Compiler compiler, BaseClassElementX cls) {
     if (cls.classMembers != null) return;
     MembersCreator creator = new MembersCreator(compiler, cls);
     creator.computeMembers();
     cls.classMembers = creator.classMembers;
     cls.interfaceMembers = creator.interfaceMembers;
   }
 }