Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/mirrors_used.dart

 // Copyright (c) 2013, 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.mirrors_used;
 
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compile_time_constants.dart' show
     ConstantCompiler;
 import 'compiler.dart' show
     Compiler;
 import 'constants/expressions.dart';
 import 'constants/values.dart' show
     ConstantValue,
     ConstructedConstantValue,
     ListConstantValue,
     StringConstantValue,
     TypeConstantValue;
 import 'dart_types.dart' show
     DartType,
     InterfaceType,
     TypeKind;
+import 'diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import 'diagnostics/messages.dart' show
     MessageKind;
 import 'diagnostics/spannable.dart' show
     Spannable;
 import 'elements/elements.dart' show
     ClassElement,
     Element,
     ImportElement,
     LibraryElement,
     MetadataAnnotation,
@@ skipping 133 matching lines @@
   final Map<ConstantValue, List<String>> cachedStrings;
   final Map<ConstantValue, List<Element>> cachedElements;
   MirrorUsage mergedMirrorUsage;
 
   MirrorUsageAnalyzer(Compiler compiler, this.task)
       : compiler = compiler,
         librariesWithUsage = new Set<LibraryElement>(),
         cachedStrings = new Map<ConstantValue, List<String>>(),
         cachedElements = new Map<ConstantValue, List<Element>>();
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   /// Collect and merge all @MirrorsUsed annotations. As a side-effect, also
   /// compute which libraries have the annotation (which is used by
   /// [MirrorUsageAnalyzerTask.hasMirrorUsage]).
   void run() {
     wildcard = compiler.libraryLoader.libraries.toList();
     Map<LibraryElement, List<MirrorUsage>> usageMap =
         collectMirrorsUsedAnnotation();
     propagateOverrides(usageMap);
     Set<LibraryElement> librariesWithoutUsage = new Set<LibraryElement>();
     usageMap.forEach((LibraryElement library, List<MirrorUsage> usage) {
       if (usage.isEmpty) librariesWithoutUsage.add(library);
     });
     if (librariesWithoutUsage.isEmpty) {
       mergedMirrorUsage = mergeUsages(usageMap);
     } else {
       mergedMirrorUsage = new MirrorUsage(null, null, null, null);
     }
   }
 
   /// Collect all @MirrorsUsed from all libraries and represent them as
   /// [MirrorUsage].
   Map<LibraryElement, List<MirrorUsage>> collectMirrorsUsedAnnotation() {
     Map<LibraryElement, List<MirrorUsage>> result =
         new Map<LibraryElement, List<MirrorUsage>>();
     for (LibraryElement library in compiler.libraryLoader.libraries) {
       if (library.isInternalLibrary) continue;
       for (ImportElement import in library.imports) {
-        compiler.withCurrentElement(library, () {
+        reporter.withCurrentElement(library, () {
           List<MirrorUsage> usages =
               mirrorsUsedOnLibraryTag(library, import);
           if (usages != null) {
             List<MirrorUsage> existing = result[library];
             if (existing != null) {
               existing.addAll(usages);
             } else {
               result[library] = usages;
             }
           }
@@ skipping 160 matching lines @@
 
   MirrorUsageBuilder(
       this.analyzer,
       this.enclosingLibrary,
       this.spannable,
       this.constant,
       this.elements);
 
   Compiler get compiler => analyzer.compiler;
 
+  DiagnosticReporter get reporter => analyzer.reporter;
+
   /// Convert a constant to a list of [String] and [Type] values. If the
   /// constant is a single [String], it is assumed to be a comma-separated list
   /// of qualified names. If the constant is a [Type] t, the result is [:[t]:].
   /// Otherwise, the constant is assumed to represent a list of strings (each a
   /// qualified name) and types, and such a list is constructed.  If
   /// [onlyStrings] is true, the returned list is a [:List<String>:] and any
   /// [Type] values are treated as an error (meaning that the value is ignored
   /// and a hint is emitted).
   List convertConstantToUsageList(
       ConstantValue constant, { bool onlyStrings: false }) {
     if (constant.isNull) {
       return null;
     } else if (constant.isList) {
       ListConstantValue list = constant;
       List result = onlyStrings ? <String> [] : [];
       for (ConstantValue entry in list.entries) {
         if (entry.isString) {
           StringConstantValue string = entry;
           result.add(string.primitiveValue.slowToString());
         } else if (!onlyStrings && entry.isType) {
           TypeConstantValue type = entry;
           result.add(type.representedType);
         } else {
           Spannable node = positionOf(entry);
           MessageKind kind = onlyStrings
               ? MessageKind.MIRRORS_EXPECTED_STRING
               : MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE;
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               node, kind, {'name': node, 'type': apiTypeOf(entry)});
         }
       }
       return result;
     } else if (!onlyStrings && constant.isType) {
       TypeConstantValue type = constant;
       return [type.representedType];
     } else if (constant.isString) {
       StringConstantValue string = constant;
       var iterable =
           string.primitiveValue.slowToString().split(',').map((e) => e.trim());
       return onlyStrings ? new List<String>.from(iterable) : iterable.toList();
     } else {
       Spannable node = positionOf(constant);
       MessageKind kind = onlyStrings
           ? MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST
           : MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST;
-      compiler.reportHintMessage(
+      reporter.reportHintMessage(
           node, kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
   DartType apiTypeOf(ConstantValue constant) {
     DartType type = constant.getType(compiler.coreTypes);
     LibraryElement library = type.element.library;
     if (type.isInterfaceType && library.isInternalLibrary) {
@@ skipping 63 matching lines @@
       }
     }
     return result;
   }
 
   /// Resolve [expression] in [enclosingLibrary]'s import scope.
   Element resolveExpression(String expression) {
     List<String> identifiers = expression.split('.');
     Element element = enclosingLibrary.find(identifiers[0]);
     if (element == null) {
-      compiler.reportHintMessage(
+      reporter.reportHintMessage(
           spannable,
           MessageKind.MIRRORS_CANNOT_RESOLVE_IN_CURRENT_LIBRARY,
           {'name': expression});
       return null;
     } else {
       if (identifiers.length == 1) return element;
       return resolveLocalExpression(element, identifiers.sublist(1));
     }
   }
 
   /// Resolve [identifiers] in [element]'s local members.
   Element resolveLocalExpression(Element element, List<String> identifiers) {
     Element current = element;
     for (String identifier in identifiers) {
       Element e = findLocalMemberIn(current, identifier);
       if (e == null) {
         if (current.isLibrary) {
           LibraryElement library = current;
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               spannable, MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
               {'name': identifiers[0],
                'library': library.libraryOrScriptName});
         } else {
-          compiler.reportHintMessage(
+          reporter.reportHintMessage(
               spannable, MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
               {'name': identifier, 'element': current.name});
         }
         return current;
       }
       current = e;
     }
     return current;
   }
 
@@ skipping 35 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }