Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/typechecker.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.typechecker;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/resolution.dart' show
     Resolution;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'core_types.dart';
 import 'dart_types.dart';
 import 'diagnostics/diagnostic_listener.dart' show
-    DiagnosticMessage;
+    DiagnosticMessage,
+    DiagnosticReporter;
 import 'diagnostics/invariant.dart' show
     invariant;
 import 'diagnostics/messages.dart';
 import 'diagnostics/spannable.dart' show
     Spannable;
 import 'elements/elements.dart' show
     AbstractFieldElement,
     AstElement,
     AsyncMarker,
     ClassElement,
@@ skipping 30 matching lines @@
 import '../compiler_new.dart' as api;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   void check(AstElement element) {
     if (element.isClass) return;
     if (element.isTypedef) return;
     ResolvedAst resolvedAst = element.resolvedAst;
-    compiler.withCurrentElement(element.implementation, () {
+    reporter.withCurrentElement(element.implementation, () {
       measure(() {
         TypeCheckerVisitor visitor = new TypeCheckerVisitor(
             compiler, resolvedAst.elements, compiler.types);
         if (element.isField) {
           visitor.analyzingInitializer = true;
         }
         resolvedAst.node.accept(visitor);
       });
     });
   }
@@ skipping 217 matching lines @@
   Node lastSeenNode;
   DartType expectedReturnType;
   AsyncMarker currentAsyncMarker = AsyncMarker.SYNC;
 
   final ClassElement currentClass;
 
   /// The immediately enclosing field, method or constructor being analyzed.
   ExecutableElement executableContext;
 
   CoreTypes get coreTypes => compiler.coreTypes;
+
+  DiagnosticReporter get reporter => compiler.reporter;
+
   Resolution get resolution => compiler.resolution;
 
   InterfaceType get intType => coreTypes.intType;
   InterfaceType get doubleType => coreTypes.doubleType;
   InterfaceType get boolType => coreTypes.boolType;
   InterfaceType get stringType => coreTypes.stringType;
 
   DartType thisType;
   DartType superType;
 
@@ skipping 71 matching lines @@
       // If these are used, an error should have been reported by the resolver.
       thisType = const DynamicType();
       superType = const DynamicType();
     }
   }
 
   LibraryElement get currentLibrary => elements.analyzedElement.library;
 
   reportTypeWarning(Spannable spannable, MessageKind kind,
                     [Map arguments = const {}]) {
-    compiler.reportWarningMessage(spannable, kind, arguments);
+    reporter.reportWarningMessage(spannable, kind, arguments);
   }
 
   reportMessage(Spannable spannable, MessageKind kind,
                 Map arguments,
                 {bool isHint: false}) {
     if (isHint) {
-      compiler.reportHintMessage(spannable, kind, arguments);
+      reporter.reportHintMessage(spannable, kind, arguments);
     } else {
-      compiler.reportWarningMessage(spannable, kind, arguments);
+      reporter.reportWarningMessage(spannable, kind, arguments);
     }
   }
 
   reportTypePromotionHint(TypePromotion typePromotion) {
     if (!reportedTypePromotions.contains(typePromotion)) {
       reportedTypePromotions.add(typePromotion);
       for (TypePromotionMessage message in typePromotion.messages) {
-        compiler.reportHint(message.hint, message.infos);
+        reporter.reportHint(message.hint, message.infos);
       }
     }
   }
 
   // TODO(karlklose): remove these functions.
   DartType unhandledExpression() => const DynamicType();
 
   DartType analyzeNonVoid(Node node) {
     DartType type = analyze(node);
     if (type.isVoid) {
       reportTypeWarning(node, MessageKind.VOID_EXPRESSION);
     }
     return type;
   }
 
   DartType analyzeWithDefault(Node node, DartType defaultValue) {
     return node != null ? analyze(node) : defaultValue;
   }
 
   /// If [inInitializer] is true, assignment should be interpreted as write to
   /// a field and not to a setter.
   DartType analyze(Node node, {bool inInitializer: false}) {
     if (node == null) {
       final String error = 'Unexpected node: null';
       if (lastSeenNode != null) {
-        compiler.internalError(lastSeenNode, error);
+        reporter.internalError(lastSeenNode, error);
       } else {
-        compiler.internalError(executableContext, error);
+        reporter.internalError(executableContext, error);
       }
     } else {
       lastSeenNode = node;
     }
     bool previouslyInitializer = analyzingInitializer;
     analyzingInitializer = inInitializer;
     DartType result = node.accept(this);
     analyzingInitializer = previouslyInitializer;
     if (result == null) {
-      compiler.internalError(node, 'Type is null.');
+      reporter.internalError(node, 'Type is null.');
     }
     return _record(node, result);
   }
 
   void checkTypePromotion(Node node, TypePromotion typePromotion,
                           {bool checkAccesses: false}) {
     VariableElement variable = typePromotion.variable;
     String variableName = variable.name;
     List<Node> potentialMutationsIn =
         elements.getPotentialMutationsIn(node, variable);
     if (!potentialMutationsIn.isEmpty) {
-      DiagnosticMessage hint = compiler.createMessage(
+      DiagnosticMessage hint = reporter.createMessage(
           typePromotion.node,
           MessageKind.POTENTIAL_MUTATION,
           {'variableName': variableName, 'shownType': typePromotion.type});
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       for (Node mutation in potentialMutationsIn) {
-        infos.add(compiler.createMessage(mutation,
+        infos.add(reporter.createMessage(mutation,
             MessageKind.POTENTIAL_MUTATION_HERE,
             {'variableName': variableName}));
       }
       typePromotion.addHint(hint, infos);
     }
     List<Node> potentialMutationsInClosures =
         elements.getPotentialMutationsInClosure(variable);
     if (!potentialMutationsInClosures.isEmpty) {
-      DiagnosticMessage hint = compiler.createMessage(
+      DiagnosticMessage hint = reporter.createMessage(
           typePromotion.node,
           MessageKind.POTENTIAL_MUTATION_IN_CLOSURE,
           {'variableName': variableName, 'shownType': typePromotion.type});
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       for (Node mutation in potentialMutationsInClosures) {
-        infos.add(compiler.createMessage(
+        infos.add(reporter.createMessage(
             mutation,
             MessageKind.POTENTIAL_MUTATION_IN_CLOSURE_HERE,
             {'variableName': variableName}));
       }
       typePromotion.addHint(hint, infos);
     }
     if (checkAccesses) {
       List<Node> accesses = elements.getAccessesByClosureIn(node, variable);
       List<Node> mutations = elements.getPotentialMutations(variable);
       if (!accesses.isEmpty && !mutations.isEmpty) {
-        DiagnosticMessage hint = compiler.createMessage(
+        DiagnosticMessage hint = reporter.createMessage(
             typePromotion.node,
             MessageKind.ACCESSED_IN_CLOSURE,
             {'variableName': variableName, 'shownType': typePromotion.type});
         List<DiagnosticMessage> infos = <DiagnosticMessage>[];
         for (Node access in accesses) {
-          infos.add(compiler.createMessage(
+          infos.add(reporter.createMessage(
               access,
               MessageKind.ACCESSED_IN_CLOSURE_HERE,
               {'variableName': variableName}));
         }
         for (Node mutation in mutations) {
-          infos.add(compiler.createMessage(
+          infos.add(reporter.createMessage(
               mutation,
               MessageKind.POTENTIAL_MUTATION_HERE,
               {'variableName': variableName}));
         }
         typePromotion.addHint(hint, infos);
       }
     }
   }
 
   /// Show type promotions from [left] and [right] in [node] given that the
@@ skipping 34 matching lines @@
 
   /**
    * Check if a value of type [from] can be assigned to a variable, parameter or
    * return value of type [to].  If `isConst == true`, an error is emitted in
    * checked mode, otherwise a warning is issued.
    */
   bool checkAssignable(Spannable spannable, DartType from, DartType to,
                        {bool isConst: false}) {
     if (!types.isAssignable(from, to)) {
       if (compiler.enableTypeAssertions && isConst) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             spannable,
             MessageKind.NOT_ASSIGNABLE,
             {'fromType': from, 'toType': to});
       } else {
-        compiler.reportWarningMessage(
+        reporter.reportWarningMessage(
             spannable,
             MessageKind.NOT_ASSIGNABLE,
             {'fromType': from, 'toType': to});
       }
       return false;
     }
     return true;
   }
 
   checkCondition(Expression condition) {
@@ skipping 311 matching lines @@
       /// Report [warning] including info(s) about the declaration of [element]
       /// or [type].
       void reportWarning(DiagnosticMessage warning) {
         // TODO(johnniwinther): Support pointing to individual parameters on
         // assignability warnings.
         List<DiagnosticMessage> infos = <DiagnosticMessage>[];
         Element declaration = element;
         if (declaration == null) {
           declaration = type.element;
         } else if (type.isTypedef) {
-          infos.add(compiler.createMessage(
+          infos.add(reporter.createMessage(
               declaration,
               MessageKind.THIS_IS_THE_DECLARATION,
               {'name': element.name}));
           declaration = type.element;
         }
         if (declaration != null) {
-          infos.add(compiler.createMessage(
+          infos.add(reporter.createMessage(
               declaration, MessageKind.THIS_IS_THE_METHOD));
         }
-        compiler.reportWarning(warning, infos);
+        reporter.reportWarning(warning, infos);
       }
 
       /// Report a warning on [node] if [argumentType] is not assignable to
       /// [parameterType].
       void checkAssignable(Spannable node,
                            DartType argumentType,
                            DartType parameterType) {
         if (!types.isAssignable(argumentType, parameterType)) {
-          reportWarning(compiler.createMessage(
+          reportWarning(reporter.createMessage(
               node,
               MessageKind.NOT_ASSIGNABLE,
               {'fromType': argumentType, 'toType': parameterType}));
         }
       }
 
       FunctionType funType = unaliasedType;
       Iterator<DartType> parameterTypes = funType.parameterTypes.iterator;
       Iterator<DartType> optionalParameterTypes =
           funType.optionalParameterTypes.iterator;
       while (!arguments.isEmpty) {
         Node argument = arguments.head;
         NamedArgument namedArgument = argument.asNamedArgument();
         if (namedArgument != null) {
           argument = namedArgument.expression;
           String argumentName = namedArgument.name.source;
           DartType namedParameterType =
               funType.getNamedParameterType(argumentName);
           if (namedParameterType == null) {
             // TODO(johnniwinther): Provide better information on the called
             // function.
-            reportWarning(compiler.createMessage(
+            reportWarning(reporter.createMessage(
                 argument,
                 MessageKind.NAMED_ARGUMENT_NOT_FOUND,
                 {'argumentName': argumentName}));
 
             DartType argumentType = analyze(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
           } else {
             DartType argumentType = analyze(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
             checkAssignable(argument, argumentType, namedParameterType);
           }
         } else {
           if (!parameterTypes.moveNext()) {
             if (!optionalParameterTypes.moveNext()) {
 
               // TODO(johnniwinther): Provide better information on the
               // called function.
-              reportWarning(compiler.createMessage(
+              reportWarning(reporter.createMessage(
                   argument, MessageKind.ADDITIONAL_ARGUMENT));
 
               DartType argumentType = analyze(argument);
               if (argumentTypes != null) argumentTypes.addLast(argumentType);
             } else {
               DartType argumentType = analyze(argument);
               if (argumentTypes != null) argumentTypes.addLast(argumentType);
               checkAssignable(
                   argument, argumentType, optionalParameterTypes.current);
             }
           } else {
             DartType argumentType = analyze(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
             checkAssignable(argument, argumentType, parameterTypes.current);
           }
         }
         arguments = arguments.tail;
       }
       if (parameterTypes.moveNext()) {
         // TODO(johnniwinther): Provide better information on the called
         // function.
-        reportWarning(compiler.createMessage(
+        reportWarning(reporter.createMessage(
             send, MessageKind.MISSING_ARGUMENT,
             {'argumentType': parameterTypes.current}));
       }
     } else {
       while(!arguments.isEmpty) {
         DartType argumentType = analyze(arguments.head);
         if (argumentTypes != null) argumentTypes.addLast(argumentType);
         arguments = arguments.tail;
       }
     }
@@ skipping 87 matching lines @@
       // foo() where foo is a method in the same class.
       return createResolvedAccess(node, name, element);
     } else if (element.isVariable ||
         element.isParameter ||
         element.isField) {
       // foo() where foo is a field in the same class.
       return createResolvedAccess(node, name, element);
     } else if (element.isGetter || element.isSetter) {
       return createResolvedAccess(node, name, element);
     } else {
-      compiler.internalError(element,
+      reporter.internalError(element,
           'Unexpected element kind ${element.kind}.');
       return null;
     }
   }
 
   ElementAccess createResolvedAccess(Send node, String name,
                                      Element element) {
     checkPrivateAccess(node, element, name);
     return createPromotedAccess(element);
   }
@@ skipping 12 matching lines @@
    * Computes the type of the access of [name] on the [node] possibly using the
    * [element] provided for [node] by the resolver.
    */
   DartType computeAccessType(Send node, String name, Element element,
                              MemberKind memberKind,
                              {bool lookupClassMember: false}) {
     DartType type =
         computeAccess(node, name, element, memberKind,
             lookupClassMember: lookupClassMember).computeType(resolution);
     if (type == null) {
-      compiler.internalError(node, 'Type is null on access of $name on $node.');
+      reporter.internalError(node, 'Type is null on access of $name on $node.');
     }
     return type;
   }
 
   /// Compute a version of [shownType] that is more specific that [knownType].
   /// This is used to provided better hints when trying to promote a supertype
   /// to a raw subtype. For instance trying to promote `Iterable<int>` to `List`
   /// we suggest the use of `List<int>`, which would make promotion valid.
   DartType computeMoreSpecificType(DartType shownType,
                                    DartType knownType) {
@@ skipping 98 matching lines @@
         if (variable != null &&
             (variable.isVariable || variable.isParameter)) {
           DartType knownType = getKnownType(variable);
           if (!knownType.isDynamic) {
             DartType shownType = elements.getType(node.arguments.head);
             TypePromotion typePromotion =
                 new TypePromotion(node, variable, shownType);
             if (!types.isMoreSpecific(shownType, knownType)) {
               String variableName = variable.name;
               if (!types.isSubtype(shownType, knownType)) {
-                typePromotion.addHint(compiler.createMessage(
+                typePromotion.addHint(reporter.createMessage(
                     node,
                     MessageKind.NOT_MORE_SPECIFIC_SUBTYPE,
                     {'variableName': variableName,
                      'shownType': shownType,
                      'knownType': knownType}));
               } else {
                 DartType shownTypeSuggestion =
                     computeMoreSpecificType(shownType, knownType);
                 if (shownTypeSuggestion != null) {
-                  typePromotion.addHint(compiler.createMessage(
+                  typePromotion.addHint(reporter.createMessage(
                       node,
                       MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
                       {'variableName': variableName,
                        'shownType': shownType,
                        'shownTypeSuggestion': shownTypeSuggestion,
                        'knownType': knownType}));
                 } else {
-                  typePromotion.addHint(compiler.createMessage(
+                  typePromotion.addHint(reporter.createMessage(
                       node,
                       MessageKind.NOT_MORE_SPECIFIC,
                       {'variableName': variableName,
                        'shownType': shownType,
                        'knownType': knownType}));
                 }
               }
             }
             showTypePromotion(node, typePromotion);
           }
@@ skipping 268 matching lines @@
         case '*=': operatorName = '*'; break;
         case '/=': operatorName = '/'; break;
         case '%=': operatorName = '%'; break;
         case '~/=': operatorName = '~/'; break;
         case '&=': operatorName = '&'; break;
         case '|=': operatorName = '|'; break;
         case '^=': operatorName = '^'; break;
         case '<<=': operatorName = '<<'; break;
         case '>>=': operatorName = '>>'; break;
         default:
-          compiler.internalError(node, 'Unexpected assignment operator $name.');
+          reporter.internalError(node, 'Unexpected assignment operator $name.');
       }
       if (node.isIndex) {
         // base[key] o= value for some operator o.
         final Node valueNode = node.arguments.tail.head;
         final DartType value = analyze(valueNode);
         return checkIndexAssignmentOperator(
             node, operatorName, valueNode, value);
       } else {
         // target o= value for some operator o.
         final Node valueNode = node.arguments.head;
@@ skipping 398 matching lines @@
               ConstantExpression caseConstant =
                   compiler.resolver.constantCompiler.compileNode(
                       caseMatch.expression, elements);
               enumValues.remove(
                   compiler.constants.getConstantValue(caseConstant));
             }
           }
         }
         unreferencedFields.addAll(enumValues.values);
         if (!unreferencedFields.isEmpty) {
-          compiler.reportWarningMessage(
+          reporter.reportWarningMessage(
               node, MessageKind.MISSING_ENUM_CASES,
               {'enumType': expressionType,
                'enumValues': unreferencedFields.map(
                    (e) => e.name).join(', ')});
         }
       });
     }
 
     return const StatementType();
   }
@@ skipping 16 matching lines @@
 
   visitCatchBlock(CatchBlock node) {
     return analyze(node.block);
   }
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
-    compiler.internalError(node,
+    reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }