Extract DiagnosticReporter implementation from Compiler.

tests/compiler/dart2js/related_types.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 related_types;
 
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/core_types.dart';
 import 'package:compiler/src/dart_types.dart';
+import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/diagnostics/messages.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/universe/call_structure.dart';
 import 'package:compiler/src/universe/selector.dart';
 import 'package:compiler/src/world.dart';
 import 'memory_compiler.dart';
 
@@ skipping 33 matching lines @@
 }
 
 /// Check [member] for unrelated types.
 void checkMemberElement(Compiler compiler, MemberElement member) {
   if (!compiler.enqueuer.resolution.hasBeenResolved(member)) return;
 
   ResolvedAst resolvedAst = member.resolvedAst;
   RelatedTypesChecker relatedTypesChecker =
       new RelatedTypesChecker(compiler, resolvedAst);
   if (resolvedAst.node != null) {
-    compiler.withCurrentElement(member.implementation, () {
+    compiler.reporter.withCurrentElement(member.implementation, () {
       relatedTypesChecker.apply(resolvedAst.node);
     });
   }
 }
 
 class RelatedTypesChecker extends TraversalVisitor<DartType, dynamic> {
   final Compiler compiler;
   final ResolvedAst resolvedAst;
 
   RelatedTypesChecker(this.compiler, ResolvedAst resolvedAst)
       : this.resolvedAst = resolvedAst,
         super(resolvedAst.elements);
 
   ClassWorld get world => compiler.world;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   InterfaceType get thisType => resolvedAst.element.enclosingClass.thisType;
 
   /// Returns `true` if there exists no common subtype of [left] and [right].
   bool hasEmptyIntersection(DartType left, DartType right) {
     if (left == right) return false;
     if (left == null || right == null) return false;
     ClassElement leftClass = const ClassFinder().findClass(left);
     ClassElement rightClass = const ClassFinder().findClass(right);
     if (leftClass != null && rightClass != null) {
       return !world.haveAnyCommonSubtypes(leftClass, rightClass);
     }
     return false;
   }
 
   /// Checks that there exists a common subtype of [left] and [right] or report
   /// a hint otherwise.
   void checkRelated(Node node, DartType left, DartType right) {
     if (hasEmptyIntersection(left, right)) {
-      compiler.reportHint(compiler.createMessage(
+      reporter.reportHintMessage(
           node,
           MessageKind.NO_COMMON_SUBTYPES,
-          {'left': left, 'right': right}));
+          {'left': left, 'right': right});
     }
   }
 
   /// Check weakly typed collection methods, like `Map.containsKey`,
   /// `Map.containsValue` and `Iterable.contains`.
   void checkDynamicInvoke(
       Node node,
       DartType receiverType,
       List<DartType> argumentTypes,
       Selector selector) {
@@ skipping 310 matching lines @@
   ClassElement findClass(DartType type) => type.accept(this, null);
 
   @override
   ClassElement visitType(DartType type, _) => null;
 
   @override
   ClassElement visitInterfaceType(InterfaceType type, _) {
     return type.element;
   }
 }