Stop concatenating prefixes and identifiers when performing lookup (issue 26069)

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 @@
             getSource(identifier),
             identifier.offset,
             identifier.length,
             CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
         return hiddenElement;
       }
     }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
+
+  @override
+  Element _internalLookupPrefixed(Identifier identifier, String prefix,
+      String name, LibraryElement referencingLibrary) {
+    return enclosingScope._internalLookupPrefixed(
+        identifier, prefix, name, referencingLibrary);
+  }
 }
 
 /**
  * The scope defined by a function.
  */
 class FunctionScope extends EnclosedScope {
   /**
    * The element representing the function that defines this scope.
    */
   final ExecutableElement _functionElement;
@@ skipping 199 matching lines @@
   @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.
    */
   LibraryImportScope(this._definingLibrary, this.errorListener) {
     _createImportedNamespaces();
   }
 
   @override
   void define(Element element) {
@@ skipping 69 matching lines @@
     List<ImportElement> imports = _definingLibrary.imports;
     int count = imports.length;
     _importedNamespaces = new List<Namespace>(count);
     for (int i = 0; i < count; i++) {
       _importedNamespaces[i] =
           builder.createImportNamespaceForDirective(imports[i]);
     }
   }
 
   /**
+   * Add the given [element] to this scope without checking for duplication or
+   * 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;
     }
     LibraryElement library = element.library;
     if (library == null) {
       return StringUtilities.EMPTY;
     }
@@ skipping 26 matching lines @@
         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++) {
+      Namespace nameSpace = _importedNamespaces[i];
+      Element element = nameSpace.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 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;
@@ skipping 128 matching lines @@
   Namespace(this._definedNames);
 
   /**
    * Return a table containing the same mappings as those defined by this
    * namespace.
    */
   Map<String, Element> get definedNames => _definedNames;
 
   /**
    * Return the element in this namespace that is available to the containing
-   * scope using the given name.
+   * scope using the given name, or `null` if there is no such element.
    */
   Element get(String name) => _definedNames[name];
+
+  /**
+   * Return the element in this namespace whose name is the result of combining
+   * the [prefix] and the [name], separated by a period, or `null` if there is
+   * no such element.
+   */
+  Element getPrefixed(String prefix, String name) => null;
 }
 
 /**
  * The builder used to build a namespace. Namespace builders are thread-safe and
  * re-usable.
  */
 class NamespaceBuilder {
   /**
    * Create a namespace representing the export namespace of the given [element].
    */
@@ skipping 26 matching lines @@
     LibraryElement importedLibrary = element.importedLibrary;
     if (importedLibrary == null) {
       //
       // The imported library will be null if the URI does not reference a valid
       // library.
       //
       return Namespace.EMPTY;
     }
     HashMap<String, Element> exportedNames = _getExportMapping(importedLibrary);
     exportedNames = _applyCombinators(exportedNames, element.combinators);
-    exportedNames = _applyPrefix(exportedNames, element.prefix);
+    PrefixElement prefix = element.prefix;
+    if (prefix != null) {
+      return new PrefixedNamespace(prefix.name, exportedNames);
+    }
     return new Namespace(exportedNames);
   }
 
   /**
    * Create a namespace representing the public namespace of the given
    * [library].
    */
   Namespace createPublicNamespaceForLibrary(LibraryElement library) {
     HashMap<String, Element> definedNames = new HashMap<String, Element>();
     _addPublicNames(definedNames, library.definingCompilationUnit);
@@ skipping 65 matching lines @@
       } else {
         // Internal error.
         AnalysisEngine.instance.logger
             .logError("Unknown type of combinator: ${combinator.runtimeType}");
       }
     }
     return definedNames;
   }
 
   /**
-   * Apply the prefix defined by the [prefixElement] to all of the names in the
-   * table of [definedNames].
-   */
-  HashMap<String, Element> _applyPrefix(
-      HashMap<String, Element> definedNames, PrefixElement prefixElement) {
-    if (prefixElement != null) {
-      String prefix = prefixElement.name;
-      HashMap<String, Element> newNames = new HashMap<String, Element>();
-      definedNames.forEach((String name, Element element) {
-        newNames["$prefix.$name"] = element;
-      });
-      return newNames;
-    } else {
-      return definedNames;
-    }
-  }
-
-  /**
    * Create a mapping table representing the export namespace of the given
    * [library]. The set of [visitedElements] contains the libraries that do not
    * need to be visited when processing the export directives of the given
    * library because all of the names defined by them will be added by another
    * library.
    */
   HashMap<String, Element> _computeExportMapping(
       LibraryElement library, HashSet<LibraryElement> visitedElements) {
     visitedElements.add(library);
     try {
@@ skipping 66 matching lines @@
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
       }
     }
     return newNames;
   }
 }
 
 /**
+ * A mapping of identifiers to the elements represented by those identifiers.
+ * Namespaces are the building blocks for scopes.
+ */
+class PrefixedNamespace implements Namespace {
+  /**
+   * The prefix that is prepended to each of the defined names.
+   */
+  final String _prefix;
+
+  /**
+   * The length of the prefix.
+   */
+  final int _length;
+
+  /**
+   * A table mapping names that are defined in this namespace to the element
+   * representing the thing declared with that name.
+   */
+  final HashMap<String, Element> _definedNames;
+
+  /**
+   * Initialize a newly created namespace to have the names resulting from
+   * prefixing each of the [_definedNames] with the given [_prefix] (and a
+   * period).
+   */
+  PrefixedNamespace(String prefix, this._definedNames)
+      : _prefix = prefix,
+        _length = prefix.length;
+
+  @override
+  Map<String, Element> get definedNames {
+    Map<String, Element> definedNames = <String, Element>{};
+    _definedNames.forEach((String name, Element element) {
+      definedNames["$_prefix.$name"] = element;
+    });
+    return definedNames;
+  }
+
+  @override
+  Element get(String name) {
+    if (name.startsWith(_prefix)) {
+      if (name.codeUnitAt(_length) == '.'.codeUnitAt(0)) {
+        return _definedNames[name.substring(_length + 1)];
+      }
+    }
+    return null;
+  }
+
+  @override
+  Element getPrefixed(String prefix, String name) {
+    if (prefix == _prefix) {
+      return _definedNames[name];
+    }
+    return null;
+  }
+}
+
+/**
  * A name scope used by the resolver to determine which names are visible at any
  * given point in the code.
  */
 abstract class Scope {
   /**
    * The prefix used to mark an identifier as being private to its library.
    */
   static int PRIVATE_NAME_PREFIX = 0x5F;
 
   /**
@@ skipping 120 matching lines @@
     }
     return null;
   }
 
   /**
    * Return the element with which the given [identifier] is associated, or
    * `null` if the name is not defined within this scope. The
    * [referencingLibrary] is the library that contains the reference to the
    * name, used to implement library-level privacy.
    */
-  Element lookup(Identifier identifier, LibraryElement referencingLibrary) =>
-      internalLookup(identifier, identifier.name, referencingLibrary);
+  Element lookup(Identifier identifier, LibraryElement referencingLibrary) {
+    if (identifier is PrefixedIdentifier) {
+      return _internalLookupPrefixed(identifier, identifier.prefix.name,
+          identifier.identifier.name, referencingLibrary);
+    }
+    return internalLookup(identifier, identifier.name, referencingLibrary);
+  }
 
   /**
    * Return the name that will be used to look up the given [element].
    */
   String _getName(Element element) {
     if (element is MethodElement) {
       MethodElement method = element;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
   }
 
   /**
+   * 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,
+      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);
 }
 
 /**
  * The scope defined by the type parameters in a class.
  */
 class TypeParameterScope extends EnclosedScope {
@@ skipping 11 matching lines @@
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }