Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/parser/partial_elements.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.partial_elements;
 
 import '../common/resolution.dart' show
     Parsing,
     Resolution;
-import '../compiler.dart' show
-    Compiler;
 import '../dart_types.dart' show DynamicType;
-import '../diagnostics/diagnostic_listener.dart';
+import '../diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart';
 import '../elements/elements.dart' show
     CompilationUnitElement,
     ConstructorElement,
     Element,
     ElementKind,
     GetterElement,
     LibraryElement,
@@ skipping 242 matching lines @@
                    Modifiers modifiers,
                    bool hasParseError)
       : super(modifiers) {
     super.beginToken = beginToken;
     super.endToken = endToken;
     super.hasParseError = hasParseError;
   }
 
   VariableDefinitions parseNode(Element element, Parsing parsing) {
     if (definitions != null) return definitions;
-    DiagnosticListener listener = parsing.listener;
-    listener.withCurrentElement(element, () {
+    DiagnosticReporter reporter = parsing.reporter;
+    reporter.withCurrentElement(element, () {
       definitions = parse(
           parsing, element, declarationSite,
           (Parser parser) => parser.parseMember(beginToken));
 
       if (!hasParseError &&
           !definitions.modifiers.isVar &&
           !definitions.modifiers.isFinal &&
           !definitions.modifiers.isConst &&
           definitions.type == null &&
           !definitions.isErroneous) {
-        listener.reportErrorMessage(
+        reporter.reportErrorMessage(
             definitions,
             MessageKind.GENERIC,
             { 'text': 'A field declaration must start with var, final, '
                       'const, or a type annotation.' });
       }
     });
     return definitions;
   }
 
   computeType(Element element, Resolution resolution) {
@@ skipping 117 matching lines @@
   bool get hasNode => cachedNode != null;
 
   ClassNode get node {
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     return cachedNode;
   }
 
   ClassNode parseNode(Parsing parsing) {
     if (cachedNode != null) return cachedNode;
-    DiagnosticListener diagnosticListener = parsing.listener;
-    diagnosticListener.withCurrentElement(this, () {
+    DiagnosticReporter reporter = parsing.reporter;
+    reporter.withCurrentElement(this, () {
       parsing.measure(() {
-        MemberListener listener = new MemberListener(diagnosticListener, this);
+        MemberListener listener = new MemberListener(reporter, this);
         Parser parser = new ClassElementParser(listener);
         try {
           Token token = parser.parseTopLevelDeclaration(beginToken);
           assert(identical(token, endToken.next));
           cachedNode = listener.popNode();
           assert(
               invariant(
                   beginToken, listener.nodes.isEmpty,
                   message: "Non-empty listener stack: ${listener.nodes}"));
         } on ParserError {
@@ skipping 33 matching lines @@
   PartialClassElement copyWithEnclosing(CompilationUnitElement enclosing) {
     return new PartialClassElement(name, beginToken, endToken, enclosing, id);
   }
 }
 
 Node parse(
     Parsing parsing,
     ElementX element,
     PartialElement partial,
     doParse(Parser parser)) {
-  DiagnosticListener diagnosticListener = parsing.listener;
+  DiagnosticReporter reporter = parsing.reporter;
   return parsing.measure(() {
-    return diagnosticListener.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element, () {
       CompilationUnitElement unit = element.compilationUnit;
-      NodeListener listener = new NodeListener(diagnosticListener, unit);
+      NodeListener listener = new NodeListener(reporter, unit);
       listener.memberErrors = listener.memberErrors.prepend(false);
       try {
         if (partial.hasParseError) {
           listener.suppressParseErrors = true;
         }
         doParse(new Parser(listener));
       } on ParserError catch (e) {
         partial.hasParseError = true;
         return new ErrorNode(element.position, e.reason);
       }
       Node node = listener.popNode();
       assert(listener.nodes.isEmpty);
       return node;
     });
   });
 }