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

pkg/analyzer/lib/src/generated/element_resolver.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.generated.element_resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart'
-    show ChildEntities, IdentifierImpl;
+    show
+        ChildEntities,
+        IdentifierImpl,
+        PrefixedIdentifierImpl,
+        SimpleIdentifierImpl;
+import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 /**
  * An object used by instances of [ResolverVisitor] to resolve references within
  * the AST structure to the elements being referenced. The requirements for the
  * element resolver are:
@@ skipping 846 matching lines @@
       identifier.staticElement = importedLibrary.loadLibraryFunction;
       return null;
     }
     //
     // Check to see whether the prefix is really a prefix.
     //
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
-        element = _resolver.nameScope.lookup(
-            new SyntheticIdentifier("${node.name}=", node), _definingLibrary);
+        Identifier setterName = new PrefixedIdentifierImpl.temp(
+            node.prefix,
+            new SimpleIdentifierImpl(new StringToken(TokenType.STRING,
+                "${node.identifier.name}=", node.identifier.offset - 1)));
+        element = _resolver.nameScope.lookup(setterName, _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_SETTER,
               identifier, [identifier.name, prefixElement.name]);
           return null;
         }
         AstNode parent = node.parent;
         if (parent is Annotation) {
           _resolver.reportErrorForNode(
@@ skipping 478 matching lines @@
    * Look for any declarations of the given [identifier] that are imported using
    * a prefix. Return the element that was found, or `null` if the name is not
    * imported using a prefix.
    */
   Element _findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     for (ImportElement importElement in _definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
-        Identifier prefixedIdentifier = new SyntheticIdentifier(
-            "${prefixElement.name}.${identifier.name}", identifier);
+        Identifier prefixedIdentifier = new PrefixedIdentifierImpl.temp(
+            new SimpleIdentifierImpl(new StringToken(TokenType.STRING,
+                prefixElement.name, prefixElement.nameOffset)),
+            identifier);
         Element importedElement =
             nameScope.lookup(prefixedIdentifier, _definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
             element = MultiplyDefinedElementImpl.fromElements(
                 _definingLibrary.context, element, importedElement);
           }
         }
@@ skipping 782 matching lines @@
           _resolver.reportErrorForNode(
               CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
               target,
               [target.name]);
         }
         //
         // Look to see whether the name of the method is really part of a
         // prefixed identifier for an imported top-level function or top-level
         // getter that returns a function.
         //
-        String name = "${target.name}.$methodName";
-        Identifier functionName = new SyntheticIdentifier(name, methodName);
+        Identifier functionName =
+            new PrefixedIdentifierImpl.temp(target, methodName);
         Element element =
             _resolver.nameScope.lookup(functionName, _definingLibrary);
         if (element != null) {
           // TODO(brianwilkerson) This isn't a method invocation, it's a
           // function invocation where the function name is a prefixed
           // identifier. Consider re-writing the AST.
           return element;
         }
       }
     }
@@ skipping 370 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }