Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/parser/element_listener.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.parser.element_listener;
 
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/messages.dart';
 import '../diagnostics/spannable.dart' show
     Spannable;
@@ skipping 45 matching lines @@
 typedef int IdGenerator();
 
 /**
  * A parser event listener designed to work with [PartialParser]. It
  * builds elements representing the top-level declarations found in
  * the parsed compilation unit and records them in
  * [compilationUnitElement].
  */
 class ElementListener extends Listener {
   final IdGenerator idGenerator;
-  final DiagnosticListener listener;
+  final DiagnosticReporter reporter;
   final CompilationUnitElementX compilationUnitElement;
   final StringValidator stringValidator;
   Link<StringQuoting> interpolationScope;
 
   Link<Node> nodes = const Link<Node>();
 
   LinkBuilder<MetadataAnnotation> metadata =
       new LinkBuilder<MetadataAnnotation>();
 
   /// Records a stack of booleans for each member parsed (a stack is used to
   /// support nested members which isn't currently possible, but it also serves
   /// as a simple way to tell we're currently parsing a member). In this case,
   /// member refers to members of a library or a class (but currently, classes
   /// themselves are not considered members).  If the top of the stack
   /// (memberErrors.head) is true, the current member has already reported at
   /// least one parse error.
   Link<bool> memberErrors = const Link<bool>();
 
   bool suppressParseErrors = false;
 
   ElementListener(
-      DiagnosticListener listener,
+      DiagnosticReporter reporter,
       this.compilationUnitElement,
       this.idGenerator)
-      : this.listener = listener,
-        stringValidator = new StringValidator(listener),
+      : this.reporter = reporter,
+        stringValidator = new StringValidator(reporter),
         interpolationScope = const Link<StringQuoting>();
 
   bool get currentMemberHasParseError {
     return !memberErrors.isEmpty && memberErrors.head;
   }
 
   void pushQuoting(StringQuoting quoting) {
     interpolationScope = interpolationScope.prepend(quoting);
   }
 
   StringQuoting popQuoting() {
     StringQuoting result = interpolationScope.head;
     interpolationScope = interpolationScope.tail;
     return result;
   }
 
   StringNode popLiteralString() {
     StringNode node = popNode();
     // TODO(lrn): Handle interpolations in script tags.
     if (node.isInterpolation) {
-      listener.internalError(node,
+      reporter.internalError(node,
           "String interpolation not supported in library tags.");
       return null;
     }
     return node;
   }
 
   bool allowLibraryTags() {
     // Library tags are only allowed in the library file itself, not
     // in sourced files.
     LibraryElement library = compilationUnitElement.implementationLibrary;
@@ skipping 70 matching lines @@
                            popMetadata(compilationUnitElement)));
   }
 
   void endPartOf(Token partKeyword, Token semicolon) {
     Expression name = popNode();
     addPartOfTag(new PartOf(partKeyword, name,
                             popMetadata(compilationUnitElement)));
   }
 
   void addPartOfTag(PartOf tag) {
-    compilationUnitElement.setPartOf(tag, listener);
+    compilationUnitElement.setPartOf(tag, reporter);
   }
 
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     if (periodBeforeName != null) {
       popNode(); // Discard name.
     }
     popNode(); // Discard node (Send or Identifier).
     pushMetadata(new PartialMetadataAnnotation(beginToken, endToken));
   }
 
@@ skipping 372 matching lines @@
     return next;
   }
 
   void recoverableError(Spannable node, String message) {
     // TODO(johnniwinther): Make recoverable errors non-fatal.
     reportFatalError(node, message);
   }
 
   void pushElement(Element element) {
     popMetadata(element);
-    compilationUnitElement.addMember(element, listener);
+    compilationUnitElement.addMember(element, reporter);
   }
 
   List<MetadataAnnotation> popMetadata(ElementX element) {
     List<MetadataAnnotation> result = metadata.toList();
     element.metadata = result;
     metadata.clear();
     return result;
   }
 
   void pushMetadata(MetadataAnnotation annotation) {
     metadata.addLast(annotation);
   }
 
   void addLibraryTag(LibraryTag tag) {
     if (!allowLibraryTags()) {
       recoverableError(tag, 'Library tags not allowed here.');
     }
     LibraryElementX implementationLibrary =
         compilationUnitElement.implementationLibrary;
-    implementationLibrary.addTag(tag, listener);
+    implementationLibrary.addTag(tag, reporter);
   }
 
   void pushNode(Node node) {
     nodes = nodes.prepend(node);
     if (VERBOSE) log("push $nodes");
   }
 
   Node popNode() {
     assert(!nodes.isEmpty);
     Node node = nodes.head;
@@ skipping 113 matching lines @@
   }
 
   void reportError(Spannable spannable,
                    MessageKind errorCode,
                    [Map arguments = const {}]) {
     if (currentMemberHasParseError) return; // Error already reported.
     if (suppressParseErrors) return;
     if (!memberErrors.isEmpty) {
       memberErrors = memberErrors.tail.prepend(true);
     }
-    listener.reportErrorMessage(spannable, errorCode, arguments);
+    reporter.reportErrorMessage(spannable, errorCode, arguments);
   }
 }