[analyzer] Dot shorthands: Utility function to find if a node needs to keep its declared type for a shorthand.

Adds a helper to use for lints and fixes for finding whether the AST node contains a dot shorthand that relies on a declared type (in the parent of that node).

The algorithm of `hasDependentDotShorthand` looks at the following:
0. If the node is a dot shorthand, return true.
1. Check that the node is a generic function, a list/map/set literal or a generic function expression -- with no explicit type arguments provided.

For method invocations:
2. Note which type parameters are used in the return type -- these are the type parameters that depend on type inference.
3. Check the parameters that have type parameters in the above set.
4. If the arguments to those parameters have dot shorthands (recursively  checked), then return true.

For list/set/maps:
2. Recurse with each key and value, checking if there's a dependent dot shorthand.

For function expressions:
2. Check each return statement to see if there's a dependent dot shorthand.

For constructor invocations:
2. Make sure there are no explicit type arguments given.
3. Check each argument with type parameters in its parameter to see if there's a dependent dot shorthand.

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

Author: kallentu

pkg/analyzer/lib/src/utilities/dot_shorthands.dart

@@ -0,0 +1,140 @@
+// Copyright (c) 2025, 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.
+
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/type_visitor.dart';
+
+/// Whether the expression is a dot shorthand or has a dot shorthand in its
+/// arguments that relies on type inference.
+bool hasDependentDotShorthand(AstNode node) {
+  if (node case DotShorthandMixin(
+    isDotShorthand: true,
+    :var correspondingParameter,
+  )) {
+    // There's no corresponding parameter, so we rely on the type provided by
+    // the for-loop or variable declaration.
+    if (correspondingParameter == null) return true;
+
+    // The type used to infer the dot shorthand is a type parameter. We need
+    // to avoid reporting a lint here.
+    if (correspondingParameter.baseElement.type is TypeParameterType) {
+      return true;
+    }
+  } else if (node case MethodInvocation(
+    methodName: SimpleIdentifier(:FunctionType staticType),
+    typeArguments: null,
+    argumentList: ArgumentList(:var arguments),
+  )) {
+    // When the static type of the method invocation is a generic function type
+    // with no explicit type arguments given, we will be inferring those types.
+    var typeParameters = staticType.typeParameters;
+    if (typeParameters.isEmpty) return false;
+
+    // The type parameters that are dependent on type inference are in the
+    // return type. We populate those type parameters.
+    //
+    // As an optimization, we filter the type parameters to only include the
+    // type parameters declared on the method invocation.
+    var returnType = staticType.returnType;
+    var dependentTypeParameters = _findTypeParametersForType(
+      returnType,
+    ).where((element) => typeParameters.contains(element));
+    if (dependentTypeParameters.isEmpty) return false;
+
+    // Then looking at every argument in the method invocation, we recursively
+    // check the arguments of parameters that have type parameters that are in
+    // the set of dependent type parameters that we calculated above.
+    for (var argument in arguments) {
+      var parameterTypeParameters = _findTypeParametersForFormalParameter(
+        argument.correspondingParameter,
+      );
+      if (parameterTypeParameters.isEmpty) continue;
+
+      if (parameterTypeParameters.any(
+        (type) => dependentTypeParameters.contains(type),
+      )) {
+        if (hasDependentDotShorthand(argument)) return true;
+      }
+    }
+  } else if (node
+      case ListLiteral(typeArguments: null, :var elements) ||
+          SetOrMapLiteral(typeArguments: null, :var elements)) {
+    // Lists, maps, and sets that have inferred type arguments need their
+    // elements verified for dot shorthands that depend on that type inference.
+    for (var element in elements) {
+      if (element is MapLiteralEntry) {
+        if (hasDependentDotShorthand(element.key) ||
+            hasDependentDotShorthand(element.value)) {
+          return true;
+        }
+      } else if (hasDependentDotShorthand(element)) {
+        return true;
+      }
+    }
+  } else if (node case FunctionExpression(:var body)) {
+    // Check if the return statement(s) of the function expression have a
+    // dependent dot shorthand.
+    switch (body) {
+      case ExpressionFunctionBody(:var expression):
+        return hasDependentDotShorthand(expression);
+      case BlockFunctionBody(block: Block(:var statements)):
+        for (var statement in statements) {
+          if (statement is ReturnStatement) {
+            var expression = statement.expression;
+            if (expression != null && hasDependentDotShorthand(expression)) {
+              return true;
+            }
+          }
+        }
+      default:
+        return false;
+    }
+  } else if (node case InstanceCreationExpressionImpl(
+    constructorName: ConstructorName(:var type),
+    :var argumentList,
+  )) {
+    // Type arguments to the constructor are explicitly given. We know that no
+    // inference information is required from any parent declared types.
+    if (type.typeArguments != null) return false;
+
+    for (var argument in argumentList.arguments) {
+      var parameterTypeParameters = _findTypeParametersForFormalParameter(
+        argument.correspondingParameter,
+      );
+      if (parameterTypeParameters.isEmpty) continue;
+      if (hasDependentDotShorthand(argument)) return true;
+    }
+  }
+  return false;
+}
+
+/// Finds and returns all the type parameter elements in the formal parameter,
+/// [parameter].
+Set<TypeParameterElement> _findTypeParametersForFormalParameter(
+  FormalParameterElement? parameter,
+) {
+  if (parameter == null) return {};
+  return _findTypeParametersForType(parameter.baseElement.type);
+}
+
+/// Finds and returns all the type parameter elements in [type].
+Set<TypeParameterElement> _findTypeParametersForType(DartType type) {
+  var typeParameterVisitor = _TypeParameterVisitor();
+  type.accept(typeParameterVisitor);
+  return typeParameterVisitor.typeParameters;
+}
+
+class _TypeParameterVisitor extends RecursiveTypeVisitor {
+  Set<TypeParameterElement> typeParameters = {};
+
+  _TypeParameterVisitor() : super(includeTypeAliasArguments: false);
+
+  @override
+  bool visitTypeParameterType(TypeParameterType type) {
+    typeParameters.add(type.element);
+    return true;
+  }
+}