[analyzer] Avoid call from one visit method to another in resolver.

When `PrefixedIdentifierResolver.resolve` rewrites a prefixed
identifier expression to a property access (which it does when the
prefix is an expression having record type), instead of making a call
from `ResolverVisitor.visitPropertyAccess` to
`ResolverVisitor.visitPropertyAccess` to resolve the rewritten
expression, use a private helper method for both code paths.

This ensures that all `visit` methods in the `ResolverVisitor` are
called solely from `ExpressionImpl.accept` or from
`ExpressionImpl.resolveExpression` (at least as far as expressions are
concerned). This will pave the way for a follow-up CL, in which I will
make sure that all expression resolution is done through the
`TypeAnalyzer.analyzeExpression` method. That will in turn allow the
analyzer to use the shared implementation of null-shorting introduced
in https://dart-review.googlesource.com/c/sdk/+/399480.

Change-Id: I782e10be2f58fdc0991b6d917f81bedd856485a9
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/399627
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/type_inference/shared_inference_log.dart

@@ -194,11 +194,7 @@ abstract interface class SharedInferenceLogWriter<
   void exitElement(Object node);
 
   /// Called when type inference has finished inferring an expression.
-  ///
-  /// [reanalyze] should be `true` if type inference will follow up by
-  /// re-inferring the same expression in a different form (and hence, it's not
-  /// necessary to assign a type to [node]).
-  void exitExpression(Object node, {bool reanalyze = false});
+  void exitExpression(Object node);
 
   /// Called when type inference has finished inferring an AST node associated
   /// with extension override syntax.
@@ -527,20 +523,14 @@ abstract class SharedInferenceLogWriterImpl<
   }
 
   @override
-  void exitExpression(Object node, {bool reanalyze = false}) {
+  void exitExpression(Object node) {
     checkCall(
         method: 'exitExpression',
         arguments: [node],
-        namedArguments: {if (reanalyze) 'reanalyze': reanalyze},
         expectedNode: node,
         expectedKind: StateKind.expression);
     bool typeRecorded = (state as ExpressionState).typeRecorded;
-    if (reanalyze) {
-      if (typeRecorded) {
-        fail('Tried to reanalyze after already recording a static type');
-      }
-      addEvent(new Event(message: 'WILL REANALYZE AS OTHER EXPRESSION'));
-    } else if (!typeRecorded) {
+    if (!typeRecorded) {
       fail('Failed to record a type for $state');
     }
     popState();

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

@@ -3411,8 +3411,7 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     var rewrittenPropertyAccess =
         _prefixedIdentifierResolver.resolve(node, contextType: contextType);
     if (rewrittenPropertyAccess != null) {
-      inferenceLogWriter?.exitExpression(node, reanalyze: true);
-      visitPropertyAccess(rewrittenPropertyAccess, contextType: contextType);
+      _resolvePropertyAccess(rewrittenPropertyAccess, contextType);
       // We did record that `node` was replaced with `rewrittenPropertyAccess`.
       // But if `rewrittenPropertyAccess` was itself rewritten, replace the
       // rewrite result of `node`.
@@ -3423,6 +3422,7 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
         }
         return true;
       }());
+      inferenceLogWriter?.exitExpression(node);
       return;
     }
     _insertImplicitCallReference(
@@ -3450,62 +3450,7 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     inferenceLogWriter?.enterExpression(node, contextType);
     checkUnreachableNode(node);
 
-    var target = node.target;
-    if (target != null) {
-      analyzeExpression(
-          target, SharedTypeSchemaView(UnknownInferredType.instance));
-      popRewrite();
-    }
-
-    if (node.isNullAware) {
-      _startNullAwareAccess(node, node.target);
-    }
-
-    var result = _propertyElementResolver.resolvePropertyAccess(
-      node: node,
-      hasRead: true,
-      hasWrite: false,
-    );
-
-    var element = result.readElement;
-
-    var propertyName = node.propertyName;
-    propertyName.staticElement = element;
-
-    DartType type;
-    if (element is MethodElement) {
-      type = element.type;
-    } else if (element is PropertyAccessorElement && element.isGetter) {
-      type = result.getType!;
-    } else if (result.functionTypeCallType != null) {
-      type = result.functionTypeCallType!;
-    } else if (result.recordField != null) {
-      type = result.recordField!.type;
-    } else if (result.atDynamicTarget) {
-      type = DynamicTypeImpl.instance;
-    } else {
-      type = InvalidTypeImpl.instance;
-    }
-
-    if (!isConstructorTearoffsEnabled) {
-      // Only perform a generic function instantiation on a [PrefixedIdentifier]
-      // in pre-constructor-tearoffs code. In constructor-tearoffs-enabled code,
-      // generic function instantiation is performed at assignability check
-      // sites.
-      // TODO(srawlins): Switch all resolution to use the latter method, in a
-      // breaking change release.
-      type = inferenceHelper.inferTearOff(node, propertyName, type,
-          contextType: contextType);
-    }
-
-    propertyName.setPseudoExpressionStaticType(type);
-    node.recordStaticType(type, resolver: this);
-    var replacement =
-        insertGenericFunctionInstantiation(node, contextType: contextType);
-
-    nullShortingTermination(node, rewrittenExpression: replacement);
-    _insertImplicitCallReference(replacement, contextType: contextType);
-    nullSafetyDeadCodeVerifier.verifyPropertyAccess(node);
+    _resolvePropertyAccess(node, contextType);
     inferenceLogWriter?.exitExpression(node);
   }
 
@@ -4140,6 +4085,65 @@ class ResolverVisitor extends ThrowingAstVisitor<void>
     callReference.setPseudoExpressionStaticType(callMethodType);
   }
 
+  void _resolvePropertyAccess(PropertyAccessImpl node, DartType contextType) {
+    var target = node.target;
+    if (target != null) {
+      analyzeExpression(
+          target, SharedTypeSchemaView(UnknownInferredType.instance));
+      popRewrite();
+    }
+
+    if (node.isNullAware) {
+      _startNullAwareAccess(node, node.target);
+    }
+
+    var result = _propertyElementResolver.resolvePropertyAccess(
+      node: node,
+      hasRead: true,
+      hasWrite: false,
+    );
+
+    var element = result.readElement;
+
+    var propertyName = node.propertyName;
+    propertyName.staticElement = element;
+
+    DartType type;
+    if (element is MethodElement) {
+      type = element.type;
+    } else if (element is PropertyAccessorElement && element.isGetter) {
+      type = result.getType!;
+    } else if (result.functionTypeCallType != null) {
+      type = result.functionTypeCallType!;
+    } else if (result.recordField != null) {
+      type = result.recordField!.type;
+    } else if (result.atDynamicTarget) {
+      type = DynamicTypeImpl.instance;
+    } else {
+      type = InvalidTypeImpl.instance;
+    }
+
+    if (!isConstructorTearoffsEnabled) {
+      // Only perform a generic function instantiation on a [PrefixedIdentifier]
+      // in pre-constructor-tearoffs code. In constructor-tearoffs-enabled code,
+      // generic function instantiation is performed at assignability check
+      // sites.
+      // TODO(srawlins): Switch all resolution to use the latter method, in a
+      // breaking change release.
+      type = inferenceHelper.inferTearOff(node, propertyName, type,
+          contextType: contextType);
+    }
+
+    propertyName.setPseudoExpressionStaticType(type);
+    node.recordStaticType(type, resolver: this);
+    var replacement =
+        insertGenericFunctionInstantiation(node, contextType: contextType);
+
+    nullShortingTermination(node, rewrittenExpression: replacement);
+    _insertImplicitCallReference(replacement, contextType: contextType);
+    nullSafetyDeadCodeVerifier.verifyPropertyAccess(node);
+  }
+
   /// Continues resolution of a [FunctionExpressionInvocation] that was created
   /// from a rewritten [MethodInvocation]. The target function is already
   /// resolved.