Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/resolution/type_resolver.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 dart2js.resolution.types;
 
 import '../common/resolution.dart' show
     Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../dart_backend/dart_backend.dart' show
     DartBackend;
 import '../dart_types.dart';
 import '../diagnostics/diagnostic_listener.dart' show
-    DiagnosticListener,
+    DiagnosticReporter,
     DiagnosticMessage;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../elements/elements.dart' show
     AmbiguousElement,
     ClassElement,
     Element,
     Elements,
     ErroneousElement,
     PrefixElement,
@@ skipping 12 matching lines @@
 import 'resolution_common.dart' show
     MappingVisitor;
 import 'scope.dart' show
     Scope;
 
 class TypeResolver {
   final Compiler compiler;
 
   TypeResolver(this.compiler);
 
-  DiagnosticListener get listener => compiler;
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Resolution get resolution => compiler.resolution;
 
   /// Tries to resolve the type name as an element.
   Element resolveTypeName(Identifier prefixName,
                           Identifier typeName,
                           Scope scope,
                           {bool deferredIsMalformed: true}) {
     Element element;
     if (prefixName != null) {
       Element prefixElement =
-          lookupInScope(compiler, prefixName, scope, prefixName.source);
+          lookupInScope(reporter, prefixName, scope, prefixName.source);
       if (prefixElement != null && prefixElement.isPrefix) {
         // The receiver is a prefix. Lookup in the imported members.
         PrefixElement prefix = prefixElement;
         element = prefix.lookupLocalMember(typeName.source);
         // TODO(17260, sigurdm): The test for DartBackend is there because
         // dart2dart outputs malformed types with prefix.
         if (element != null &&
             prefix.isDeferred &&
             deferredIsMalformed &&
             compiler.backend is! DartBackend) {
           element = new ErroneousElementX(MessageKind.DEFERRED_TYPE_ANNOTATION,
                                           {'node': typeName},
                                           element.name,
                                           element);
         }
       } else {
         // The caller of this method will create the ErroneousElement for
         // the MalformedType.
         element = null;
       }
     } else {
-      element = lookupInScope(compiler, typeName, scope, typeName.source);
+      element = lookupInScope(reporter, typeName, scope, typeName.source);
     }
     return element;
   }
 
   DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
                                  {bool malformedIsError: false,
                                   bool deferredIsMalformed: true}) {
     ResolutionRegistry registry = visitor.registry;
 
     Identifier typeName;
@@ skipping 36 matching lines @@
     Element element = resolveTypeName(prefixName, typeName, visitor.scope,
                                       deferredIsMalformed: deferredIsMalformed);
 
     DartType reportFailureAndCreateType(
         MessageKind messageKind,
         Map messageArguments,
         {DartType userProvidedBadType,
          Element erroneousElement,
          List<DiagnosticMessage> infos: const <DiagnosticMessage>[]}) {
       if (malformedIsError) {
-        listener.reportError(
-            listener.createMessage(node, messageKind, messageArguments),
+        reporter.reportError(
+            reporter.createMessage(node, messageKind, messageArguments),
             infos);
       } else {
         registry.registerThrowRuntimeError();
-        listener.reportWarning(
-            listener.createMessage(node, messageKind, messageArguments),
+        reporter.reportWarning(
+            reporter.createMessage(node, messageKind, messageArguments),
             infos);
       }
       if (erroneousElement == null) {
         registry.registerThrowRuntimeError();
         erroneousElement = new ErroneousElementX(
             messageKind, messageArguments, typeName.source,
             visitor.enclosingElement);
       }
       List<DartType> arguments = <DartType>[];
       resolveTypeArguments(visitor, node, const <DartType>[], arguments);
       return new MalformedType(erroneousElement,
               userProvidedBadType, arguments);
     }
 
     // Try to construct the type from the element.
     if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind,
           ambiguous.messageArguments,
           infos: ambiguous.computeInfos(
-              registry.mapping.analyzedElement, compiler));
+              registry.mapping.analyzedElement, reporter));
       ;
     } else if (element.isErroneous) {
       if (element is ErroneousElement) {
         type = reportFailureAndCreateType(
             element.messageKind, element.messageArguments,
             erroneousElement: element);
       } else {
         type = const DynamicType();
       }
     } else if (!element.impliesType) {
@@ skipping 52 matching lines @@
           registry.registerThrowRuntimeError();
           type = reportFailureAndCreateType(
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node},
               userProvidedBadType: typeVariable.type);
         } else {
           type = typeVariable.type;
         }
         type = checkNoTypeArguments(type);
       } else {
-        compiler.internalError(node,
+        reporter.internalError(node,
             "Unexpected element kind ${element.kind}.");
       }
       if (addTypeVariableBoundsCheck) {
         registry.registerTypeVariableBoundCheck();
         visitor.addDeferredAction(
             visitor.enclosingElement,
             () => checkTypeVariableBounds(node, type));
       }
     }
     registry.useType(node, type);
     return type;
   }
 
   /// Checks the type arguments of [type] against the type variable bounds.
   void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
     void checkTypeVariableBound(_, DartType typeArgument,
                                    TypeVariableType typeVariable,
                                    DartType bound) {
       if (!compiler.types.isSubtype(typeArgument, bound)) {
-        compiler.reportWarningMessage(
+        reporter.reportWarningMessage(
             node,
             MessageKind.INVALID_TYPE_VARIABLE_BOUND,
             {'typeVariable': typeVariable,
              'bound': bound,
              'typeArgument': typeArgument,
              'thisType': type.element.thisType});
       }
     };
 
     compiler.types.checkTypeVariableBounds(type, checkTypeVariableBound);
@@ skipping 12 matching lines @@
     if (node.typeArguments == null) {
       return false;
     }
     int expectedVariables = typeVariables.length;
     int index = 0;
     bool typeArgumentCountMismatch = false;
     for (Link<Node> typeArguments = node.typeArguments.nodes;
          !typeArguments.isEmpty;
          typeArguments = typeArguments.tail, index++) {
       if (index > expectedVariables - 1) {
-        compiler.reportWarningMessage(
+        reporter.reportWarningMessage(
             typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
         typeArgumentCountMismatch = true;
       }
       DartType argType = resolveTypeAnnotation(visitor, typeArguments.head);
       // TODO(karlklose): rewrite to not modify [arguments].
       arguments.add(argType);
     }
     if (index < expectedVariables) {
-      compiler.reportWarningMessage(
+      reporter.reportWarningMessage(
           node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
       typeArgumentCountMismatch = true;
     }
     return typeArgumentCountMismatch;
   }
 }