Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/elements/elements.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 elements;
 
 import '../common/resolution.dart' show
     Resolution;
 import '../compiler.dart' show
     Compiler;
@@ skipping 409 matching lines @@
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
     return e == null || e.isErroneous;
   }
   static bool isErroneous(Element e) => e != null && e.isErroneous;
 
   /// Unwraps [element] reporting any warnings attached to it, if any.
   static Element unwrap(Element element,
-                        DiagnosticListener listener,
+                        DiagnosticReporter listener,
                         Spannable spannable) {
     if (element != null && element.isWarnOnUse) {
       WarnOnUseElement wrappedElement = element;
       element = wrappedElement.unwrap(listener, spannable);
     }
     return element;
   }
 
   static bool isClass(Element e) => e != null && e.kind == ElementKind.CLASS;
   static bool isTypedef(Element e) {
@@ skipping 358 matching lines @@
 }
 
 /// An [Element] whose usage should cause one or more warnings.
 abstract class WarnOnUseElement extends Element {
   /// The element whose usage cause a warning.
   Element get wrappedElement;
 
   /// Reports the attached warning and returns the wrapped element.
   /// [usageSpannable] is used to report messages on the reference of
   /// [wrappedElement].
-  Element unwrap(DiagnosticListener listener, Spannable usageSpannable);
+  Element unwrap(DiagnosticReporter listener, Spannable usageSpannable);
 }
 
 /// An ambiguous element represents multiple elements accessible by the same
 /// name.
 ///
 /// Ambiguous elements are created during handling of import/export scopes. If
 /// an ambiguous element is encountered during resolution a warning/error is
 /// reported.
 abstract class AmbiguousElement extends Element {
   MessageKind get messageKind;
   Map get messageArguments;
   Element get existingElement;
   Element get newElement;
 
   /// Compute the info messages associated with an error/warning on [context].
   List<DiagnosticMessage> computeInfos(
-      Element context, DiagnosticListener listener);
+      Element context, DiagnosticReporter listener);
 }
 
 // TODO(kasperl): This probably shouldn't be called an element. It's
 // just an interface shared by classes and libraries.
 abstract class ScopeContainerElement implements Element {
   Element localLookup(String elementName);
 
   void forEachLocalMember(f(Element element));
 }
 
@@ skipping 871 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }