Don't create artificial PrefixedIdentifierImpl to check for ignored undefined.

Change-Id: I8ef06680b4d87ba017abeb5b3a70999eed25fca0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155920
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>

Author: scheglov

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

@@ -97,7 +97,7 @@ class MethodInvocationResolver {
     if (receiver is SimpleIdentifier) {
       var receiverElement = receiver.staticElement;
       if (receiverElement is PrefixElement) {
-        _resolveReceiverPrefix(node, receiver, receiverElement, nameNode, name);
+        _resolveReceiverPrefix(node, receiverElement, nameNode, name);
         return;
       }
     }
@@ -236,11 +236,13 @@ class MethodInvocationResolver {
   }
 
   void _reportUndefinedFunction(
-      MethodInvocation node, Identifier ignorableIdentifier) {
+    MethodInvocation node, {
+    @required String prefix,
+    @required String name,
+  }) {
     _setDynamicResolution(node);
 
-    // TODO(scheglov) This is duplication.
-    if (nameScope.shouldIgnoreUndefined(ignorableIdentifier)) {
+    if (nameScope.shouldIgnoreUndefined2(prefix: prefix, name: name)) {
       return;
     }
 
@@ -513,7 +515,11 @@ class MethodInvocationResolver {
     } else if (_resolver.enclosingExtension != null) {
       receiverType = _resolver.enclosingExtension.extendedType;
     } else {
-      return _reportUndefinedFunction(node, node.methodName);
+      return _reportUndefinedFunction(
+        node,
+        prefix: null,
+        name: node.methodName.name,
+      );
     }
 
     _resolveReceiverType(
@@ -526,8 +532,8 @@ class MethodInvocationResolver {
     );
   }
 
-  void _resolveReceiverPrefix(MethodInvocation node, SimpleIdentifier receiver,
-      PrefixElement prefix, SimpleIdentifier nameNode, String name) {
+  void _resolveReceiverPrefix(MethodInvocation node, PrefixElement prefix,
+      SimpleIdentifier nameNode, String name) {
     // Note: prefix?.bar is reported as an error in ElementResolver.
 
     if (name == FunctionElement.LOAD_LIBRARY_NAME) {
@@ -543,9 +549,6 @@ class MethodInvocationResolver {
       }
     }
 
-    // TODO(scheglov) I don't like how we resolve prefixed names.
-    // But maybe this is the only one solution.
-    var prefixedName = PrefixedIdentifierImpl.temp(receiver, nameNode);
     var element = prefix.scope.lookup2(name).getter;
     element = _resolver.toLegacyElement(element);
     nameNode.staticElement = element;
@@ -563,7 +566,11 @@ class MethodInvocationResolver {
       return _setResolution(node, element.type);
     }
 
-    _reportUndefinedFunction(node, prefixedName);
+    _reportUndefinedFunction(
+      node,
+      prefix: prefix.name,
+      name: name,
+    );
   }
 
   void _resolveReceiverSuper(MethodInvocation node, SuperExpression receiver,

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

@@ -11,6 +11,7 @@ import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/scope.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:meta/meta.dart';
 
 /// The scope defined by a block.
 class BlockScope {
@@ -406,24 +407,34 @@ class PrefixedNamespace implements Namespace {
 
 extension ScopeExtension on Scope {
   /// Return `true` if the fact that the given [node] is not defined should be
-  /// ignored (from the perspective of error reporting). This will be the case
-  /// if there is at least one import that defines the node's prefix, and if
-  /// that import either has no show combinators or has a show combinator that
-  /// explicitly lists the node's name.
+  /// ignored (from the perspective of error reporting).
   bool shouldIgnoreUndefined(Identifier node) {
     if (node is PrefixedIdentifier) {
-      return _enclosingLibraryScope.shouldIgnoreUndefined(
+      return shouldIgnoreUndefined2(
         prefix: node.prefix.name,
         name: node.identifier.name,
       );
     }
 
-    return _enclosingLibraryScope.shouldIgnoreUndefined(
+    return shouldIgnoreUndefined2(
       prefix: null,
       name: (node as SimpleIdentifier).name,
     );
   }
 
+  /// Return `true` if the fact that the identifier with the given [prefix]
+  /// (might be `null`) and [name] is not defined should be ignored (from the
+  /// perspective of error reporting).
+  bool shouldIgnoreUndefined2({
+    @required String prefix,
+    @required String name,
+  }) {
+    return _enclosingLibraryScope.shouldIgnoreUndefined(
+      prefix: prefix,
+      name: name,
+    );
+  }
+
   List<ExtensionElement> get extensions {
     return _enclosingLibraryScope.extensions;
   }