Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/parser/node_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.node_listener;
 
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/messages.dart';
 import '../diagnostics/spannable.dart' show
     Spannable,
@@ skipping 13 matching lines @@
 import '../util/util.dart' show
     Link;
 
 import 'element_listener.dart' show
     ElementListener;
 import 'partial_elements.dart' show
     PartialFunctionElement;
 
 class NodeListener extends ElementListener {
   NodeListener(
-      DiagnosticListener listener,
+      DiagnosticReporter reporter,
       CompilationUnitElement element)
-    : super(listener, element, null);
+    : super(reporter, element, null);
 
   void addLibraryTag(LibraryTag tag) {
     pushNode(tag);
   }
 
   void addPartOfTag(PartOf tag) {
     pushNode(tag);
   }
 
   void endClassDeclaration(int interfacesCount, Token beginToken,
@@ skipping 145 matching lines @@
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     Expression expression = popNode();
     pushNode(new Yield(yieldToken, starToken, expression, endToken));
   }
 
   void endExpressionStatement(Token token) {
     pushNode(new ExpressionStatement(popNode(), token));
   }
 
   void handleOnError(Token token, var errorInformation) {
-    listener.internalError(token, "'${token.value}': ${errorInformation}");
+    reporter.internalError(token, "'${token.value}': ${errorInformation}");
   }
 
   Token expectedFunctionBody(Token token) {
     if (identical(token.stringValue, 'native')) {
       return native.handleNativeFunctionBody(this, token);
     } else if (token is ErrorToken) {
       pushNode(null);
       reportErrorToken(token);
     } else {
       reportFatalError(token,
@@ skipping 50 matching lines @@
       }
       if (argumentSend.receiver != null) internalError(node: argument);
       if (argument is SendSet) internalError(node: argument);
       pushNode(argument.asSend().copyWithReceiver(receiver,
             identical(tokenString, '?.')));
     } else {
       NodeList arguments = new NodeList.singleton(argument);
       pushNode(new Send(receiver, new Operator(token), arguments));
     }
     if (identical(tokenString, '===')) {
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           token,
           MessageKind.UNSUPPORTED_EQ_EQ_EQ,
           {'lhs': receiver, 'rhs': argument});
     }
     if (identical(tokenString, '!==')) {
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           token,
           MessageKind.UNSUPPORTED_BANG_EQ_EQ,
           {'lhs': receiver, 'rhs': argument});
     }
   }
 
   void beginCascade(Token token) {
     pushNode(new CascadeReceiver(popNode(), token));
   }
 
@@ skipping 154 matching lines @@
   }
 
   void endAwaitExpression(Token awaitToken, Token endToken) {
     Expression expression = popNode();
     pushNode(new Await(awaitToken, expression));
   }
 
   void endRethrowStatement(Token throwToken, Token endToken) {
     pushNode(new Rethrow(throwToken, endToken));
     if (identical(throwToken.stringValue, 'throw')) {
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           throwToken, MessageKind.UNSUPPORTED_THROW_WITHOUT_EXP);
     }
   }
 
   void handleUnaryPrefixExpression(Token token) {
     pushNode(new Send.prefix(popNode(), new Operator(token)));
   }
 
   void handleSuperExpression(Token token) {
     pushNode(new Identifier(token));
@@ skipping 342 matching lines @@
     pushNode(new Label(name, colon));
   }
 
   void endLabeledStatement(int labelCount) {
     Statement statement = popNode();
     NodeList labels = makeNodeList(labelCount, null, null, null);
     pushNode(new LabeledStatement(labels, statement));
   }
 
   void log(message) {
-    listener.log(message);
+    reporter.log(message);
   }
 
   void internalError({Token token, Node node}) {
-    // TODO(ahe): This should call listener.internalError.
+    // TODO(ahe): This should call reporter.internalError.
     Spannable spannable = (token == null) ? node : token;
     throw new SpannableAssertionFailure(spannable, 'Internal error in parser.');
   }
 }