Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/elements/modelx.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 elements.modelx;
 
 import '../common/resolution.dart' show
     Resolution,
     Parsing;
 import '../compiler.dart' show
@@ skipping 53 matching lines @@
   final int hashCode = ++elementHashCode;
   List<MetadataAnnotation> metadataInternal;
 
   ElementX(this.name, this.kind, this.enclosingElement) {
     assert(isErroneous || implementationLibrary != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(Parsing parsing) {
-    parsing.listener.internalError(this,
+    parsing.reporter.internalError(this,
         'parseNode not implemented on $this.');
     return null;
   }
 
   void set metadata(List<MetadataAnnotation> metadata) {
     assert(metadataInternal == null);
     for (MetadataAnnotationX annotation in metadata) {
       assert(annotation.annotatedElement == null);
       annotation.annotatedElement = this;
     }
@@ skipping 379 matching lines @@
   final WrappedMessage info;
 
   /// The element whose usage cause a warning.
   final Element wrappedElement;
 
   WarnOnUseElementX(WrappedMessage this.warning, WrappedMessage this.info,
                     Element enclosingElement, Element wrappedElement)
       : this.wrappedElement = wrappedElement,
         super(wrappedElement.name, ElementKind.WARN_ON_USE, enclosingElement);
 
-  Element unwrap(DiagnosticListener listener, Spannable usageSpannable) {
+  Element unwrap(DiagnosticReporter reporter, Spannable usageSpannable) {
     var unwrapped = wrappedElement;
     if (warning != null) {
       Spannable spannable = warning.spannable;
       if (spannable == null) spannable = usageSpannable;
-      DiagnosticMessage warningMessage = listener.createMessage(
+      DiagnosticMessage warningMessage = reporter.createMessage(
           spannable, warning.messageKind, warning.messageArguments);
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       if (info != null) {
         Spannable spannable = info.spannable;
         if (spannable == null) spannable = usageSpannable;
-        infos.add(listener.createMessage(
+        infos.add(reporter.createMessage(
             spannable, info.messageKind, info.messageArguments));
       }
-      listener.reportWarning(warningMessage, infos);
+      reporter.reportWarning(warningMessage, infos);
     }
     if (unwrapped.isWarnOnUse) {
-      unwrapped = unwrapped.unwrap(listener, usageSpannable);
+      unwrapped = unwrapped.unwrap(reporter, usageSpannable);
     }
     return unwrapped;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitWarnOnUseElement(this, arg);
   }
 }
 
 abstract class AmbiguousElementX extends ElementX implements AmbiguousElement {
@@ skipping 29 matching lines @@
     while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
   }
 
   List<DiagnosticMessage> computeInfos(Element context,
-                                   DiagnosticListener listener) {
+                                       DiagnosticReporter reporter) {
     return const <DiagnosticMessage>[];
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAmbiguousElement(this, arg);
   }
 
   bool get isTopLevel => false;
 
   DynamicType get type => const DynamicType();
 }
 
 /// Element synthesized to diagnose an ambiguous import.
 class AmbiguousImportX extends AmbiguousElementX {
   AmbiguousImportX(
       MessageKind messageKind,
       Map messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : super(messageKind, messageArguments, enclosingElement, existingElement,
               newElement);
 
   List<DiagnosticMessage> computeInfos(
       Element context,
-      DiagnosticListener listener) {
+      DiagnosticReporter reporter) {
     List<DiagnosticMessage> infos = <DiagnosticMessage>[];
     Setlet ambiguousElements = flatten();
     MessageKind code = (ambiguousElements.length == 1)
         ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
     LibraryElementX importer = context.library;
     for (Element element in ambiguousElements) {
       Map arguments = {'name': element.name};
-      infos.add(listener.createMessage(element, code, arguments));
-      listener.withCurrentElement(importer, () {
+      infos.add(reporter.createMessage(element, code, arguments));
+      reporter.withCurrentElement(importer, () {
         for (ImportElement import in importer.importers.getImports(element)) {
-          infos.add(listener.createMessage(
+          infos.add(reporter.createMessage(
               import, MessageKind.IMPORTED_HERE, arguments));
         }
       });
     }
     return infos;
   }
 }
 
 /// Element synthesized to recover from a duplicated member of an element.
 class DuplicatedElementX extends AmbiguousElementX {
@@ skipping 10 matching lines @@
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
   }
 
-  void add(Element element, DiagnosticListener listener) {
+  void add(Element element, DiagnosticReporter reporter) {
     String name = element.name;
     if (element.isAccessor) {
-      addAccessor(element, contents[name], listener);
+      addAccessor(element, contents[name], reporter);
     } else {
       Element existing = contents.putIfAbsent(name, () => element);
       if (!identical(existing, element)) {
-        listener.reportError(
-            listener.createMessage(
+        reporter.reportError(
+            reporter.createMessage(
                 element,
                 MessageKind.DUPLICATE_DEFINITION,
                 {'name': name}),
             <DiagnosticMessage>[
-                listener.createMessage(
+                reporter.createMessage(
                     existing,
                     MessageKind.EXISTING_DEFINITION,
                     {'name': name}),
             ]);
       }
     }
   }
 
   /**
    * Adds a definition for an [accessor] (getter or setter) to a scope.
    * The definition binds to an abstract field that can hold both a getter
    * and a setter.
    *
    * The abstract field is added once, for the first getter or setter, and
    * reused if the other one is also added.
    * The abstract field should not be treated as a proper member of the
    * container, it's simply a way to return two results for one lookup.
    * That is, the getter or setter does not have the abstract field as enclosing
    * element, they are enclosed by the class or compilation unit, as is the
    * abstract field.
    */
   void addAccessor(AccessorElementX accessor,
                    Element existing,
-                   DiagnosticListener listener) {
+                   DiagnosticReporter reporter) {
     void reportError(Element other) {
-      listener.reportError(
-          listener.createMessage(
+      reporter.reportError(
+          reporter.createMessage(
               accessor,
               MessageKind.DUPLICATE_DEFINITION,
               {'name': accessor.name}),
           <DiagnosticMessage>[
-              listener.createMessage(
+              reporter.createMessage(
                   other,
                   MessageKind.EXISTING_DEFINITION,
                   {'name': accessor.name}),
           ]);
 
       contents[accessor.name] = new DuplicatedElementX(
           MessageKind.DUPLICATE_DEFINITION, {'name': accessor.name},
           accessor.memberContext.enclosingElement, other, accessor);
     }
 
@@ skipping 22 matching lines @@
     } else {
       Element container = accessor.enclosingClassOrCompilationUnit;
       AbstractFieldElementX field =
           new AbstractFieldElementX(accessor.name, container);
       accessor.abstractField = field;
       if (accessor.isGetter) {
         field.getter = accessor;
       } else {
         field.setter = accessor;
       }
-      add(field, listener);
+      add(field, reporter);
     }
   }
 }
 
 class CompilationUnitElementX extends ElementX
     with CompilationUnitElementCommon
     implements CompilationUnitElement {
   final Script script;
   PartOf partTag;
   Link<Element> localMembers = const Link<Element>();
@@ skipping 19 matching lines @@
     if (metadataInternal == null) {
       metadataInternal = <MetadataAnnotation>[];
     }
     metadataInternal.addAll(metadata);
   }
 
   void forEachLocalMember(f(Element element)) {
     localMembers.forEach(f);
   }
 
-  void addMember(Element element, DiagnosticListener listener) {
+  void addMember(Element element, DiagnosticReporter reporter) {
     // Keep a list of top level members.
     localMembers = localMembers.prepend(element);
     // Provide the member to the library to build scope.
     if (enclosingElement.isPatch) {
-      implementationLibrary.addMember(element, listener);
+      implementationLibrary.addMember(element, reporter);
     } else {
-      library.addMember(element, listener);
+      library.addMember(element, reporter);
     }
   }
 
-  void setPartOf(PartOf tag, DiagnosticListener listener) {
+  void setPartOf(PartOf tag, DiagnosticReporter reporter) {
     LibraryElementX library = enclosingElement;
     if (library.entryCompilationUnit == this) {
       partTag = tag;
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           tag, MessageKind.IMPORT_PART_OF);
       return;
     }
     if (!localMembers.isEmpty) {
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           tag, MessageKind.BEFORE_TOP_LEVEL);
       return;
     }
     if (partTag != null) {
-      listener.reportWarningMessage(tag, MessageKind.DUPLICATED_PART_OF);
+      reporter.reportWarningMessage(tag, MessageKind.DUPLICATED_PART_OF);
       return;
     }
     partTag = tag;
     LibraryName libraryTag = library.libraryTag;
     String actualName = tag.name.toString();
     if (libraryTag != null) {
       String expectedName = libraryTag.name.toString();
       if (expectedName != actualName) {
-        listener.reportWarningMessage(
+        reporter.reportWarningMessage(
             tag.name,
             MessageKind.LIBRARY_NAME_MISMATCH,
             {'libraryName': expectedName});
       }
     } else {
-      listener.reportWarning(
-          listener.createMessage(
+      reporter.reportWarning(
+          reporter.createMessage(
               library,
               MessageKind.MISSING_LIBRARY_NAME,
               {'libraryName': actualName}),
           <DiagnosticMessage>[
-              listener.createMessage(
+              reporter.createMessage(
                   tag.name,
                   MessageKind.THIS_IS_THE_PART_OF_TAG),
           ]);
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   Element get analyzableElement => library;
 
@@ skipping 38 matching lines @@
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element enclosingElement,
                  Element element,
                  ImportElement import,
-                 DiagnosticListener listener) {
+                 DiagnosticReporter reporter) {
     LibraryElementX library = enclosingElement.library;
     Importers importers = library.importers;
 
     String name = element.name;
 
     // The loadLibrary function always shadows existing bindings to that name.
     if (element.isDeferredLoaderGetter) {
       importScope.remove(name);
       // TODO(sigurdm): Print a hint.
     }
     Element existing = importScope.putIfAbsent(name, () => element);
     importers.registerImport(element, import);
 
     void registerWarnOnUseElement(ImportElement import,
                                   MessageKind messageKind,
                                   Element hidingElement,
                                   Element hiddenElement) {
       Uri hiddenUri = hiddenElement.library.canonicalUri;
       Uri hidingUri = hidingElement.library.canonicalUri;
       Element element = new WarnOnUseElementX(
           new WrappedMessage(
               null, // Report on reference to [hidingElement].
               messageKind,
               {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
           new WrappedMessage(
-              listener.spanFromSpannable(import),
+              reporter.spanFromSpannable(import),
               MessageKind.IMPORTED_HERE,
               {'name': name}),
           enclosingElement, hidingElement);
       importScope[name] = element;
       importers.registerImport(element, import);
     }
 
     if (existing != element) {
       ImportElement existingImport = importers.getImport(existing);
       if (existing.library.isPlatformLibrary &&
@@ skipping 181 matching lines @@
   }
 
   CompilationUnitElement get compilationUnit => entryCompilationUnit;
 
   Element get analyzableElement => this;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
-  void addTag(LibraryTag tag, DiagnosticListener listener) {
+  void addTag(LibraryTag tag, DiagnosticReporter reporter) {
     if (tagsCache != null) {
-      listener.internalError(tag,
+      reporter.internalError(tag,
           "Library tags for $this have already been computed.");
     }
     tagsBuilder.addLast(tag);
   }
 
   Iterable<LibraryTag> get tags {
     if (tagsCache == null) {
       tagsCache = tagsBuilder.toList();
       tagsBuilder = null;
     }
@@ skipping 14 matching lines @@
 
   /**
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element element,
                  ImportElement import,
-                 DiagnosticListener listener) {
-    importScope.addImport(this, element, import, listener);
+                 DiagnosticReporter reporter) {
+    importScope.addImport(this, element, import, reporter);
   }
 
-  void addMember(Element element, DiagnosticListener listener) {
+  void addMember(Element element, DiagnosticReporter reporter) {
     localMembers = localMembers.prepend(element);
-    addToScope(element, listener);
+    addToScope(element, reporter);
   }
 
-  void addToScope(Element element, DiagnosticListener listener) {
-    localScope.add(element, listener);
+  void addToScope(Element element, DiagnosticReporter reporter) {
+    localScope.add(element, reporter);
   }
 
   Element localLookup(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       result = origin.localLookup(elementName);
     }
     return result;
   }
 
@@ skipping 157 matching lines @@
   bool get isTopLevel => false;
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Resolution resolution) => const DynamicType();
 
   Token get position => firstPosition;
 
   void addImport(Element element,
                  ImportElement import,
-                 DiagnosticListener listener) {
-    importScope.addImport(this, element, import, listener);
+                 DiagnosticReporter reporter) {
+    importScope.addImport(this, element, import, reporter);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitPrefixElement(this, arg);
   }
 
   String toString() => '$kind($name)';
 }
 
 class TypedefElementX extends ElementX
@@ skipping 51 matching lines @@
   TypedefType createType(List<DartType> typeArguments) {
     return new TypedefType(this, typeArguments);
   }
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Resolution resolution) {
     if (hasBeenCheckedForCycles) return;
-    var visitor = new TypedefCyclicVisitor(resolution.listener, this);
+    TypedefCyclicVisitor visitor =
+        new TypedefCyclicVisitor(resolution.reporter, this);
     computeType(resolution).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
@@ skipping 900 matching lines @@
 
   bool get hasNode => constructor.hasNode;
 
   FunctionExpression get node => constructor.node;
 
   List<MetadataAnnotation> get metadata => constructor.metadata;
 
   bool get isInstanceMember => true;
 
   FunctionType computeType(Resolution resolution) {
-    resolution.listener.internalError(this, '$this.computeType.');
+    DiagnosticReporter reporter = resolution.reporter;
+    reporter.internalError(this, '$this.computeType.');
     return null;
   }
 
   Token get position => constructor.position;
 
   Element get outermostEnclosingMemberOrTopLevel => constructor;
 
   Element get analyzableElement => constructor.analyzableElement;
 
   accept(ElementVisitor visitor, arg) {
@@ skipping 247 matching lines @@
   }
 
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveClass(this);
       resolution.registerClass(this);
     }
   }
 
   void setDefaultConstructor(FunctionElement constructor,
-                             DiagnosticListener listener);
+                             DiagnosticReporter reporter);
 
   void addBackendMember(Element member) {
     // TODO(ngeoffray): Deprecate this method.
     assert(member.isGenerativeConstructorBody);
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
   }
@@ skipping 72 matching lines @@
     }
     return localMembersCache;
   }
 
   ClassElementX(String name, Element enclosing, int id, int initialState)
       : super(name, enclosing, id, initialState);
 
   bool get isMixinApplication => false;
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
-  void addMember(Element element, DiagnosticListener listener) {
+  void addMember(Element element, DiagnosticReporter reporter) {
     localMembersCache = null;
     localMembersReversed = localMembersReversed.prepend(element);
-    addToScope(element, listener);
+    addToScope(element, reporter);
   }
 
-  void addToScope(Element element, DiagnosticListener listener) {
+  void addToScope(Element element, DiagnosticReporter reporter) {
     if (element.isField && element.name == name) {
-      listener.reportErrorMessage(
+      reporter.reportErrorMessage(
           element, MessageKind.MEMBER_USES_CLASS_NAME);
     }
-    localScope.add(element, listener);
+    localScope.add(element, reporter);
   }
 
   Element localLookup(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       result = origin.localLookup(elementName);
     }
     return result;
   }
 
   void forEachLocalMember(void f(Element member)) {
     localMembers.forEach(f);
   }
 
   bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.values) {
       if (element.isConstructor) return true;
     }
     return false;
   }
 
   void setDefaultConstructor(FunctionElement constructor,
-                             DiagnosticListener listener) {
+                             DiagnosticReporter reporter) {
     // The default constructor, although synthetic, is part of a class' API.
-    addMember(constructor, listener);
+    addMember(constructor, reporter);
   }
 
   List<DartType> computeTypeParameters(Parsing parsing) {
     ClassNode node = parseNode(parsing);
     return createTypeVariables(node.typeParameters);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
@@ skipping 151 matching lines @@
     return mixedInElement.isInstanceMember ? mixedInElement : null;
   }
 
   void forEachLocalMember(void f(Element member)) {
     constructors.forEach(f);
     if (mixin != null) mixin.forEachLocalMember((Element mixedInElement) {
       if (mixedInElement.isInstanceMember) f(mixedInElement);
     });
   }
 
-  void addMember(Element element, DiagnosticListener listener) {
+  void addMember(Element element, DiagnosticReporter reporter) {
     throw new UnsupportedError("Cannot add member to $this.");
   }
 
-  void addToScope(Element element, DiagnosticListener listener) {
-    listener.internalError(this, 'Cannot add to scope of $this.');
+  void addToScope(Element element, DiagnosticReporter reporter) {
+    reporter.internalError(this, 'Cannot add to scope of $this.');
   }
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(FunctionElement constructor,
-                             DiagnosticListener listener) {
+                             DiagnosticReporter reporter) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
   List<DartType> computeTypeParameters(Parsing parsing) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) {
       throw new SpannableAssertionFailure(node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
@@ skipping 222 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }