Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/dart_types.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 dart_types;
 
 import 'dart:math' show min;
 
 import 'common/resolution.dart' show
     Resolution;
 import 'compiler.dart' show
     Compiler;
 import 'core_types.dart';
+import 'diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import 'diagnostics/invariant.dart' show
     invariant;
 import 'diagnostics/spannable.dart' show
     CURRENT_ELEMENT_SPANNABLE,
     NO_LOCATION_SPANNABLE;
 import 'elements/modelx.dart' show
     LibraryElementX,
     TypeDeclarationElementX,
     TypedefElementX;
 import 'elements/elements.dart';
@@ skipping 1211 matching lines @@
 }
 
 class Types implements DartTypes {
   // TODO(johnniwinther): Replace by [CoreTypes].
   final Compiler compiler;
   final MoreSpecificVisitor moreSpecificVisitor;
   final SubtypeVisitor subtypeVisitor;
   final PotentialSubtypeVisitor potentialSubtypeVisitor;
 
   CoreTypes get coreTypes => compiler.coreTypes;
+
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Resolution get resolution => compiler.resolution;
 
   Types(Compiler compiler)
       : this.compiler = compiler,
         this.moreSpecificVisitor = new MoreSpecificVisitor(compiler),
         this.subtypeVisitor = new SubtypeVisitor(compiler),
         this.potentialSubtypeVisitor = new PotentialSubtypeVisitor(compiler);
 
   Types copy(Compiler compiler) {
     return new Types(compiler);
@@ skipping 281 matching lines @@
     int maxCommonDepth = min(aClass.hierarchyDepth, bClass.hierarchyDepth);
     for (int depth = maxCommonDepth; depth >= 0; depth--) {
       Set<DartType> aTypeSet = getSupertypesAtDepth(a, depth);
       Set<DartType> bTypeSet = getSupertypesAtDepth(b, depth);
       Set<DartType> intersection = aTypeSet..retainAll(bTypeSet);
       if (intersection.length == 1) {
         return intersection.first;
       }
     }
 
-    compiler.internalError(CURRENT_ELEMENT_SPANNABLE,
+    reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
         'No least upper bound computed for $a and $b.');
     return null;
   }
 
   /// Computes the least upper bound of the types in the longest prefix of [a]
   /// and [b].
   List<DartType> computeLeastUpperBoundsTypes(List<DartType> a,
                                               List<DartType> b) {
     if (a.isEmpty || b.isEmpty) return const <DartType>[];
     int prefixLength = min(a.length, b.length);
@@ skipping 402 matching lines @@
         }
         namedParameterTypes[index].accept(this, namedParameters[index]);
         needsComma = true;
       }
       sb.write('}');
     }
     sb.write(')');
   }
 }