[analyzer] Dot shorthands: Refactoring MethodInvocationResolver to handle dot shorthands.

This is the base preliminary work for resolving dot shorthand invocations. I'll be calling `resolveDotShorthand` from the `Resolver` in a future CL.

Dot shorthand invocation resolution is very similar to normal MethodInvocation resolution, with a few exceptions (like no `target` expression), so it made sense to re-use the logic we had in the `MethodInvocationResolver`.

I refactored `_rewriteAsFunctionExpressionInvocation` heavily to support both dot shorthands and method invocations, which involved pulling out all of the members into parameters.

Most `_report<some error>` methods were refactored to support dot shorthands as well. Half of them called `_setInvalidTypeResolution` and that ended up just being invoked at the call site rather than in the report helper itself.

Dot shorthands has a very basic `DotShorthandInvocationInferrer` in this CL. None of the overrides for a `MethodInvocationInferrer` seemed to apply since we don't have a target.

No tests yet. Tests will be added once I make the next CL that calls this `resolveDotShorthand` entry point.

Bug: #59835
Change-Id: I8ebeb772c30c88b85ae68d805e062accb1d6d17d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/421560
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: kallentu

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

@@ -155,14 +155,35 @@ class InvocationInferenceHelper {
     return tearOffType;
   }
 
+  /// Finish resolution of the [DotShorthandInvocation].
+  ///
+  /// We have already found the invoked [ExecutableElement2], and the [rawType]
+  /// is its not yet instantiated type. Here we perform downwards inference,
+  /// resolution of arguments, and upwards inference.
+  void resolveDotShorthandInvocation({
+    required DotShorthandInvocationImpl node,
+    required FunctionTypeImpl rawType,
+    required List<WhyNotPromotedGetter> whyNotPromotedArguments,
+    required TypeImpl contextType,
+  }) {
+    var returnType = DotShorthandInvocationInferrer(
+      resolver: _resolver,
+      node: node,
+      argumentList: node.argumentList,
+      contextType: contextType,
+      whyNotPromotedArguments: whyNotPromotedArguments,
+    ).resolveInvocation(rawType: rawType);
+    node.recordStaticType(returnType, resolver: _resolver);
+  }
+
   /// Finish resolution of the [MethodInvocation].
   ///
   /// We have already found the invoked [ExecutableElement2], and the [rawType]
   /// is its not yet instantiated type. Here we perform downwards inference,
   /// resolution of arguments, and upwards inference.
   void resolveMethodInvocation({
     required MethodInvocationImpl node,
-    required FunctionType rawType,
+    required FunctionTypeImpl rawType,
     required List<WhyNotPromotedGetter> whyNotPromotedArguments,
     required TypeImpl contextType,
   }) {
@@ -172,11 +193,7 @@ class InvocationInferenceHelper {
       argumentList: node.argumentList,
       contextType: contextType,
       whyNotPromotedArguments: whyNotPromotedArguments,
-    ).resolveInvocation(
-        // TODO(paulberry): eliminate this cast by changing the type of
-        // `rawType`.
-        rawType: rawType as FunctionTypeImpl);
-
+    ).resolveInvocation(rawType: rawType);
     node.recordStaticType(returnType, resolver: _resolver);
   }
 }

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

@@ -131,6 +131,19 @@ class AugmentedInvocationInferrer
       CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
 }
 
+/// Specialization of [InvocationInferrer] for performing type inference on AST
+/// nodes of type [DotShorthandInvocation].
+class DotShorthandInvocationInferrer
+    extends InvocationExpressionInferrer<DotShorthandInvocationImpl> {
+  DotShorthandInvocationInferrer(
+      {required super.resolver,
+      required super.node,
+      required super.argumentList,
+      required super.contextType,
+      required super.whyNotPromotedArguments})
+      : super._();
+}
+
 /// Specialization of [InvocationInferrer] for performing type inference on AST
 /// nodes that require full downward and upward inference.
 abstract class FullInvocationInferrer<Node extends AstNodeImpl>