Remove the final error being generated in a scope

pkg/analyzer/lib/src/dart/resolver/scope.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.resolver.scope;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 110 matching lines @@
    * The scope in which this scope is lexically enclosed.
    */
   @override
   final Scope enclosingScope;
 
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope].
    */
   EnclosedScope(this.enclosingScope);
 
+  @deprecated
   @override
   AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   @override
   Element internalLookup(
       Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
 
   @override
-  Element _internalLookupPrefixed(Identifier identifier, String prefix,
+  Element _internalLookupPrefixed(PrefixedIdentifier identifier, String prefix,
       String name, LibraryElement referencingLibrary) {
     return enclosingScope._internalLookupPrefixed(
         identifier, prefix, name, referencingLibrary);
   }
 }
 
 /**
  * The scope defined by a function.
  */
 class FunctionScope extends EnclosedScope {
@@ skipping 188 matching lines @@
     }
     return _outerScope?.lookup(targetLabel);
   }
 }
 
 /**
  * The scope containing all of the names available from imported libraries.
  */
 class LibraryImportScope extends Scope {
   /**
+   * The name of the property containing a list of the elements from the SDK
+   * that conflict with the single name imported from non-SDK libraries. The
+   * value of the property is always of type `List<Element>`.
+   */
+  static const String conflictingSdkElements = 'conflictingSdkElements';
+
+  /**
    * The element representing the library in which this scope is enclosed.
    */
   final LibraryElement _definingLibrary;
 
-  /**
-   * The listener that is to be informed when an error is encountered.
-   */
+  @deprecated
   @override
   final AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces;
 
   /**
    * A table mapping prefixes that have been referenced to a map from the names
    * that have been referenced to the element associated with the prefixed name.
    */
   Map<String, Map<String, Element>> _definedPrefixedNames;
 
   /**
    * Initialize a newly created scope representing the names imported into the
-   * [_definingLibrary]. The [errorListener] is the listener that is to be
-   * informed when an error is encountered.
+   * [_definingLibrary]. The [errorListener] is no longer used and should be
+   * omitted.
    */
-  LibraryImportScope(this._definingLibrary, this.errorListener) {
+  LibraryImportScope(this._definingLibrary, [this.errorListener]) {
     _createImportedNamespaces();
   }
 
   @override
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
   @override
   Source getSource(AstNode node) {
     Source source = super.getSource(node);
     if (source == null) {
       source = _definingLibrary.definingCompilationUnit.source;
     }
     return source;
   }
 
   @override
   Element internalLookup(
       Identifier identifier, String name, LibraryElement referencingLibrary) {
-    Element foundElement = localLookup(name, referencingLibrary);
-    if (foundElement != null) {
-      return foundElement;
+    Element element = localLookup(name, referencingLibrary);
+    if (element != null) {
+      return element;
     }
-    for (int i = 0; i < _importedNamespaces.length; i++) {
-      Namespace nameSpace = _importedNamespaces[i];
-      Element element = nameSpace.get(name);
-      if (element != null) {
-        if (foundElement == null) {
-          foundElement = element;
-        } else if (!identical(foundElement, element)) {
-          foundElement = MultiplyDefinedElementImpl.fromElements(
-              _definingLibrary.context, foundElement, element);
-        }
-      }
+    element = _lookupInImportedNamespaces(
+        identifier, (Namespace namespace) => namespace.get(name));
+    if (element != null) {
+      defineNameWithoutChecking(name, element);
     }
-    Element element = foundElement;
-    if (element is MultiplyDefinedElementImpl) {
-      foundElement = _removeSdkElements(identifier, name, element);
-    }
-    if (foundElement is MultiplyDefinedElementImpl) {
-      String foundEltName = foundElement.displayName;
-      List<Element> conflictingMembers = foundElement.conflictingElements;
-      int count = conflictingMembers.length;
-      List<String> libraryNames = new List<String>(count);
-      for (int i = 0; i < count; i++) {
-        libraryNames[i] = _getLibraryName(conflictingMembers[i]);
-      }
-      libraryNames.sort();
-      errorListener.onError(new AnalysisError(
-          getSource(identifier),
-          identifier.offset,
-          identifier.length,
-          StaticWarningCode.AMBIGUOUS_IMPORT, [
-        foundEltName,
-        StringUtilities.printListOfQuotedNames(libraryNames)
-      ]));
-      return foundElement;
-    }
-    if (foundElement != null) {
-      defineNameWithoutChecking(name, foundElement);
-    }
-    return foundElement;
+    return element;
   }
 
   @override
   bool shouldIgnoreUndefined(Identifier node) {
     Iterable<NamespaceCombinator> getShowCombinators(
             ImportElement importElement) =>
         importElement.combinators.where((NamespaceCombinator combinator) =>
             combinator is ShowElementCombinator);
     if (node is PrefixedIdentifier) {
       String prefix = node.prefix.name;
@@ skipping 57 matching lines @@
    * hiding.
    */
   void _definePrefixedNameWithoutChecking(
       String prefix, String name, Element element) {
     _definedPrefixedNames ??= new HashMap<String, Map<String, Element>>();
     Map<String, Element> unprefixedNames = _definedPrefixedNames.putIfAbsent(
         prefix, () => new HashMap<String, Element>());
     unprefixedNames[name] = element;
   }
 
-  /**
-   * Return the name of the library that defines given [element].
-   */
-  String _getLibraryName(Element element) {
-    if (element == null) {
-      return StringUtilities.EMPTY;
+  @override
+  Element _internalLookupPrefixed(PrefixedIdentifier identifier, String prefix,
+      String name, LibraryElement referencingLibrary) {
+    Element element = _localPrefixedLookup(prefix, name);
+    if (element != null) {
+      return element;
     }
-    LibraryElement library = element.library;
-    if (library == null) {
-      return StringUtilities.EMPTY;
+    element = _lookupInImportedNamespaces(identifier.identifier,
+        (Namespace namespace) => namespace.getPrefixed(prefix, name));
+    if (element != null) {
+      _definePrefixedNameWithoutChecking(prefix, name, element);
     }
-    List<ImportElement> imports = _definingLibrary.imports;
-    int count = imports.length;
-    for (int i = 0; i < count; i++) {
-      if (identical(imports[i].importedLibrary, library)) {
-        return library.definingCompilationUnit.displayName;
-      }
-    }
-    List<String> indirectSources = new List<String>();
-    for (int i = 0; i < count; i++) {
-      LibraryElement importedLibrary = imports[i].importedLibrary;
-      if (importedLibrary != null) {
-        for (LibraryElement exportedLibrary
-            in importedLibrary.exportedLibraries) {
-          if (identical(exportedLibrary, library)) {
-            indirectSources
-                .add(importedLibrary.definingCompilationUnit.displayName);
-          }
-        }
-      }
-    }
-    int indirectCount = indirectSources.length;
-    StringBuffer buffer = new StringBuffer();
-    buffer.write(library.definingCompilationUnit.displayName);
-    if (indirectCount > 0) {
-      buffer.write(" (via ");
-      if (indirectCount > 1) {
-        indirectSources.sort();
-        buffer.write(StringUtilities.printListOfQuotedNames(indirectSources));
-      } else {
-        buffer.write(indirectSources[0]);
-      }
-      buffer.write(")");
-    }
-    return buffer.toString();
-  }
-
-  @override
-  Element _internalLookupPrefixed(Identifier identifier, String prefix,
-      String name, LibraryElement referencingLibrary) {
-    Element foundElement = _localPrefixedLookup(prefix, name);
-    if (foundElement != null) {
-      return foundElement;
-    }
-    for (int i = 0; i < _importedNamespaces.length; i++) {
-      Element element = _importedNamespaces[i].getPrefixed(prefix, name);
-      if (element != null) {
-        if (foundElement == null) {
-          foundElement = element;
-        } else if (!identical(foundElement, element)) {
-          foundElement = MultiplyDefinedElementImpl.fromElements(
-              _definingLibrary.context, foundElement, element);
-        }
-      }
-    }
-    Element element = foundElement;
-    if (element is MultiplyDefinedElementImpl) {
-      foundElement = _removeSdkElements(identifier, name, element);
-    }
-    if (foundElement is MultiplyDefinedElementImpl) {
-      String foundEltName = foundElement.displayName;
-      List<Element> conflictingMembers = foundElement.conflictingElements;
-      int count = conflictingMembers.length;
-      List<String> libraryNames = new List<String>(count);
-      for (int i = 0; i < count; i++) {
-        libraryNames[i] = _getLibraryName(conflictingMembers[i]);
-      }
-      libraryNames.sort();
-      errorListener.onError(new AnalysisError(
-          getSource(identifier),
-          identifier.offset,
-          identifier.length,
-          StaticWarningCode.AMBIGUOUS_IMPORT, [
-        foundEltName,
-        StringUtilities.printListOfQuotedNames(libraryNames)
-      ]));
-      return foundElement;
-    }
-    if (foundElement != null) {
-      _definePrefixedNameWithoutChecking(prefix, name, foundElement);
-    }
-    return foundElement;
+    return element;
   }
 
   /**
    * Return the element with which the given [prefix] and [name] are associated,
    * or `null` if the name is not defined within this scope.
    */
   Element _localPrefixedLookup(String prefix, String name) {
     if (_definedPrefixedNames != null) {
       Map<String, Element> unprefixedNames = _definedPrefixedNames[prefix];
       if (unprefixedNames != null) {
         return unprefixedNames[name];
       }
     }
     return null;
   }
 
-  /**
-   * Given a collection of elements (captured by the [foundElement]) that the
-   * [identifier] (with the given [name]) resolved to, remove from the list all
-   * of the names defined in the SDK and return the element(s) that remain.
-   */
-  Element _removeSdkElements(Identifier identifier, String name,
-      MultiplyDefinedElementImpl foundElement) {
-    List<Element> conflictingElements = foundElement.conflictingElements;
-    List<Element> nonSdkElements = new List<Element>();
-    Element sdkElement = null;
-    for (Element member in conflictingElements) {
-      if (member.library.isInSdk) {
-        sdkElement = member;
-      } else {
-        nonSdkElements.add(member);
+  Element _lookupInImportedNamespaces(
+      Identifier identifier, Element lookup(Namespace namespace)) {
+    Set<Element> sdkElements = new HashSet<Element>.identity();
+    Set<Element> nonSdkElements = new HashSet<Element>.identity();
+    for (int i = 0; i < _importedNamespaces.length; i++) {
+      Element element = lookup(_importedNamespaces[i]);
+      if (element != null) {
+        if (element.library.isInSdk) {
+          sdkElements.add(element);
+        } else {
+          nonSdkElements.add(element);
+        }
       }
     }
-    if (sdkElement != null && nonSdkElements.length > 0) {
-      String sdkLibName = _getLibraryName(sdkElement);
-      String otherLibName = _getLibraryName(nonSdkElements[0]);
-      errorListener.onError(new AnalysisError(
-          getSource(identifier),
-          identifier.offset,
-          identifier.length,
-          StaticWarningCode.CONFLICTING_DART_IMPORT,
-          [name, sdkLibName, otherLibName]));
+    int nonSdkCount = nonSdkElements.length;
+    int sdkCount = sdkElements.length;
+    if (nonSdkCount == 0) {
+      if (sdkCount == 0) {
+        return null;
+      } else if (sdkCount == 1) {
+        return sdkElements.first;
+      }
     }
-    if (nonSdkElements.length == conflictingElements.length) {
-      // None of the members were removed
-      return foundElement;
-    } else if (nonSdkElements.length == 1) {
-      // All but one member was removed
-      return nonSdkElements[0];
-    } else if (nonSdkElements.length == 0) {
-      // All members were removed
-      AnalysisEngine.instance.logger
-          .logInformation("Multiply defined SDK element: $foundElement");
-      return foundElement;
+    if (nonSdkCount == 1) {
+      if (sdkCount > 0) {
+        identifier.setProperty(
+            conflictingSdkElements, sdkElements.toList(growable: false));
+      }
+      return nonSdkElements.first;
     }
     return new MultiplyDefinedElementImpl(
-        _definingLibrary.context, nonSdkElements);
+        _definingLibrary.context,
+        sdkElements.toList(growable: false),
+        nonSdkElements.toList(growable: false));
   }
 }
 
 /**
  * A scope containing all of the names defined in a given library.
  */
 class LibraryScope extends EnclosedScope {
   /**
    * Initialize a newly created scope representing the names defined in the
-   * [definingLibrary]. The [errorListener] is the listener that is to be
-   * informed when an error is encountered
+   * [definingLibrary]. The [errorListener] is no longer used and should be
+   * omitted.
    */
-  LibraryScope(
-      LibraryElement definingLibrary, AnalysisErrorListener errorListener)
+  LibraryScope(LibraryElement definingLibrary,
+      [@deprecated AnalysisErrorListener errorListener])
       : super(new LibraryImportScope(definingLibrary, errorListener)) {
     _defineTopLevelNames(definingLibrary);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       // TODO(scheglov) consider providing actual 'nameOffset' from the
       // synthetic accessor
       int offset = duplicate.nameOffset;
@@ skipping 398 matching lines @@
   HashMap<String, Element> _definedNames = null;
 
   /**
    * Return the scope in which this scope is lexically enclosed.
    */
   Scope get enclosingScope => null;
 
   /**
    * Return the listener that is to be informed when an error is encountered.
    */
+  @deprecated
   AnalysisErrorListener get errorListener;
 
   /**
    * Add the given [element] to this scope. If there is already an element with
    * the given name defined in this scope, then an error will be generated and
    * the original element will continue to be mapped to the name. If there is an
    * element with the given name in an enclosing scope, then a warning will be
    * generated but the given element will hide the inherited element.
    */
   void define(Element element) {
@@ skipping 122 matching lines @@
   }
 
   /**
    * Return the element with which the given [prefix] and [name] are associated,
    * or `null` if the name is not defined within this scope. The [identifier] is
    * the identifier node to lookup element for, used to report correct kind of a
    * problem and associate problem with. The [referencingLibrary] is the library
    * that contains the reference to the name, used to implement library-level
    * privacy.
    */
-  Element _internalLookupPrefixed(Identifier identifier, String prefix,
+  Element _internalLookupPrefixed(PrefixedIdentifier identifier, String prefix,
       String name, LibraryElement referencingLibrary);
 
   /**
    * Return `true` if the given [name] is a library-private name.
    */
   static bool isPrivateName(String name) =>
       name != null && StringUtilities.startsWithChar(name, PRIVATE_NAME_PREFIX);
 }
 
 /**
@@ skipping 14 matching lines @@
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }