Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/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 dart2js.resolution.compute_members;
 
 import '../common/names.dart' show
     Identifiers;
 import '../common/resolution.dart' show
     Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart';
 import '../diagnostics/diagnostic_listener.dart' show
-    DiagnosticMessage;
+    DiagnosticMessage,
+    DiagnosticReporter;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../elements/elements.dart' show
     ClassElement,
     Element,
     LibraryElement,
     Member,
     MemberElement,
@@ skipping 16 matching lines @@
       new Map<dynamic, Set<MessageKind>>();
 
   MembersCreator(Compiler this.compiler,
                  ClassElement this.cls,
                  Iterable<String> this.computedMemberNames,
                  Map<Name, Member> this.classMembers) {
     assert(invariant(cls, cls.isDeclaration,
         message: "Members may only be computed on declarations."));
   }
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Resolution get resolution => compiler.resolution;
 
   void reportMessage(var marker, MessageKind kind, report()) {
     Set<MessageKind> messages =
         reportedMessages.putIfAbsent(marker,
             () => new Set<MessageKind>());
     if (messages.add(kind)) {
       report();
     }
   }
@@ skipping 191 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.reportWarningMessage(
+        reporter.reportWarningMessage(
             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, () {
-          DiagnosticMessage warning = compiler.createMessage(
+          DiagnosticMessage warning = reporter.createMessage(
               cls,
               interfaceMember.declarations.length == 1
                   ? singleKind : multipleKind,
               {'class': cls.name,
                'name': name.text,
                'method': interfaceMember,
                'declarer': inherited.declarer});
           List<DiagnosticMessage> infos = <DiagnosticMessage>[];
           for (Member inherited in interfaceMember.declarations) {
-            infos.add(compiler.createMessage(
+            infos.add(reporter.createMessage(
                 inherited.element,
                 inherited.isDeclaredByField ?
                     implicitlyDeclaredKind : explicitlyDeclaredKind,
                 {'class': inherited.declarer.name,
                  'name': name.text}));
           }
-          compiler.reportWarning(warning, infos);
+          reporter.reportWarning(warning, infos);
         });
       }
       if (interfaceMember.isSetter) {
         reportWarning(MessageKind.UNIMPLEMENTED_SETTER_ONE,
                       MessageKind.UNIMPLEMENTED_SETTER,
                       MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER,
                       MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER);
       } else if (interfaceMember.isGetter) {
         reportWarning(MessageKind.UNIMPLEMENTED_GETTER_ONE,
                       MessageKind.UNIMPLEMENTED_GETTER,
@@ skipping 14 matching lines @@
   void checkImplementsFunctionWithCall() {
     assert(!cls.isAbstract);
 
     if (cls.asInstanceOf(compiler.functionClass) == null) return;
     if (cls.lookupMember(Identifiers.call) != null) return;
     // TODO(johnniwinther): Make separate methods for backend exceptions.
     // Avoid warnings on backend implementation classes for closures.
     if (compiler.backend.isBackendLibrary(cls.library)) return;
 
     reportMessage(compiler.functionClass, MessageKind.UNIMPLEMENTED_METHOD, () {
-      compiler.reportWarningMessage(
+      reporter.reportWarningMessage(
           cls,
           MessageKind.UNIMPLEMENTED_METHOD_ONE,
           {'class': cls.name,
            'name': Identifiers.call,
            'method': Identifiers.call,
            'declarer': compiler.functionClass.name});
     });
   }
 
   /// Checks that a class member exists for every interface member.
   void checkInterfaceImplementation();
 
   /// Check that [declared] is a valid override of [superMember].
   void checkValidOverride(Member declared, MemberSignature superMember) {
     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.reportWarning(
-                  compiler.createMessage(
+              reporter.reportWarning(
+                  reporter.createMessage(
                       declared.element,
                       MessageKind.INSTANCE_STATIC_SAME_NAME,
                       {'memberName': declared.name,
                        'className': superclass.name}),
                   <DiagnosticMessage>[
-                      compiler.createMessage(
+                      reporter.createMessage(
                           superMember.element,
                           MessageKind.INSTANCE_STATIC_SAME_NAME_CONT),
                   ]);
 
             });
             break;
           }
           superclass = superclass.superclass;
         }
       }
@@ skipping 26 matching lines @@
           // An error should already have been reported.
           assert(invariant(declared.element, compiler.compilationFailed,
               message: "Member $inherited inherited from its "
                        "declaring class: ${cls}."));
           continue;
         }
 
         void reportError(MessageKind errorKind, MessageKind infoKind) {
           reportMessage(
               inherited.element, MessageKind.INVALID_OVERRIDE_METHOD, () {
-            compiler.reportError(
-                compiler.createMessage(
+            reporter.reportError(
+                reporter.createMessage(
                     declared.element,
                     errorKind,
                     {'name': declared.name.text,
                      'class': cls.thisType,
                      'inheritedClass': inherited.declarer}),
                 <DiagnosticMessage>[
-                    compiler.createMessage(
+                    reporter.createMessage(
                         inherited.element,
                         infoKind,
                         {'name': declared.name.text,
                          'class': inherited.declarer}),
                 ]);
           });
         }
 
         if (declared.isDeclaredByField && inherited.isMethod) {
           reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD,
                       MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT);
         } else if (declared.isMethod && inherited.isDeclaredByField) {
           reportError(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
                       MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
         } else if (declared.isGetter && inherited.isMethod) {
           reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER,
                       MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT);
         } 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.reportWarning(
-                    compiler.createMessage(
+                reporter.reportWarning(
+                    reporter.createMessage(
                         declared.element,
                         warningKind,
                         {'declaredType': declared.type,
                          'name': declared.name.text,
                          'class': cls.thisType,
                          'inheritedType': inherited.type,
                          'inheritedClass': inherited.declarer}),
                     <DiagnosticMessage>[
-                        compiler.createMessage(
+                        reporter.createMessage(
                             inherited.element,
                             infoKind,
                             {'name': declared.name.text,
                              'class': inherited.declarer}),
                     ]);
               });
             }
             if (declared.isDeclaredByField) {
               if (inherited.isDeclaredByField) {
                 reportWarning(inherited.element,
@@ skipping 36 matching lines @@
           }
         }
       }
     }
   }
 
   void reportErrorWithContext(Element errorneousElement,
                               MessageKind errorMessage,
                               Element contextElement,
                               MessageKind contextMessage) {
-    compiler.reportError(
-        compiler.createMessage(
+    reporter.reportError(
+        reporter.createMessage(
             errorneousElement,
             errorMessage,
             {'memberName': contextElement.name,
              'className': contextElement.enclosingClass.name}),
         <DiagnosticMessage>[
-            compiler.createMessage(contextElement, contextMessage),
+            reporter.createMessage(contextElement, contextMessage),
         ]);
   }
 
   /// Compute all class and interface names by the [name] in [cls].
   static void computeClassMembersByName(Compiler compiler,
                                         ClassMemberMixin cls,
                                         String name) {
     if (cls.isMemberComputed(name)) return;
     LibraryElement library = cls.library;
     _computeClassMember(compiler, cls, name,
@@ skipping 183 matching lines @@
           for (MemberSignature other in inheritedMembers) {
             if (!compiler.types.isSubtype(inherited.functionType,
                                           other.functionType)) {
               continue outer;
             }
           }
           subtypesOfAllInherited.putIfAbsent(inherited.functionType,
               () => new Setlet<Member>()).add(inherited);
         }
         if (someAreGetters && !allAreGetters) {
-          DiagnosticMessage warning = compiler.createMessage(
+          DiagnosticMessage warning = reporter.createMessage(
               cls,
               MessageKind.INHERIT_GETTER_AND_METHOD,
               {'class': thisType, 'name': name.text });
           List<DiagnosticMessage> infos = <DiagnosticMessage>[];
           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;
               } else {
                 kind = MessageKind.INHERITED_EXPLICIT_GETTER;
               }
             }
-            infos.add(compiler.createMessage(
+            infos.add(reporter.createMessage(
                 inherited.element,
                 kind,
                 {'class': inherited.declarer, 'name': name.text}));
           }
-          compiler.reportWarning(warning, infos);
+          reporter.reportWarning(warning, infos);
           interfaceMembers[name] = new ErroneousMember(inheritedMembers);
         } else if (subtypesOfAllInherited.length == 1) {
           // All signatures have the same type.
           Setlet<Member> members = subtypesOfAllInherited.values.first;
           MemberSignature inherited = members.first;
           if (members.length != 1) {
             // Multiple signatures with the same type => return a
             // synthesized signature.
             inherited = new SyntheticMember(
                 members, inherited.type, inherited.functionType);
@@ skipping 194 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }