Fixes create method inside record literals

[email protected]

Fixes #58266

Change-Id: I33e6d21099d4f6b64556b45df3fca5dbfa4d3ed2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/396561
Auto-Submit: Felipe Morschel <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Phil Quitslund <[email protected]>

Author: FMorschel

pkg/analysis_server/lib/src/services/correction/dart/create_method_or_function.dart

@@ -11,6 +11,7 @@ import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/utilities/extensions/collection.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 import 'package:analyzer_plugin/utilities/range_factory.dart';
@@ -58,17 +59,42 @@ class CreateMethodOrFunction extends ResolvedCorrectionProducer {
       // should be argument of some invocation
       // or child of an expression that is one
       var parameterElement = argument.correspondingParameter;
+      int? recordFieldIndex;
       if (argument.parent case ConditionalExpression parent) {
         if (argument == parent.condition) {
           return;
         }
         parameterElement = parent.correspondingParameter;
+      } else if (argument.parent case RecordLiteral record) {
+        parameterElement = record.correspondingParameter;
+        for (var (index, field)
+            in record.fields.whereNotType<NamedExpression>().indexed) {
+          if (field == argument) {
+            recordFieldIndex = index;
+            break;
+          }
+        }
       }
       if (parameterElement == null) {
         return;
       }
       // should be parameter of function type
       var parameterType = parameterElement.type;
+      if (parameterType is RecordType) {
+        // Finds the corresponding field for argument
+        if (argument is NamedExpression) {
+          var fieldName = argument.name.label.name;
+          for (var field in parameterType.namedFields) {
+            if (field.name == fieldName) {
+              parameterType = field.type;
+              break;
+            }
+          }
+        } else if (recordFieldIndex != null) {
+          var field = parameterType.positionalFields[recordFieldIndex];
+          parameterType = field.type;
+        }
+      }
       if (parameterType is InterfaceType && parameterType.isDartCoreFunction) {
         parameterType = FunctionTypeImpl(
           typeFormals: const [],

pkg/analysis_server/test/src/services/correction/fix/create_function_test.dart

@@ -433,6 +433,46 @@ void f2(int p) {}
 ''');
   }
 
+  Future<void> test_functionType_inside_record_functionType() async {
+    await resolveTestCode('''
+void f1(int i) {
+  f2((0, f3));
+}
+
+void f2((int, int Function(int)) f) {}
+''');
+    await assertHasFix('''
+void f1(int i) {
+  f2((0, f3));
+}
+
+void f2((int, int Function(int)) f) {}
+
+int f3(int p1) {
+}
+''');
+  }
+
+  Future<void> test_functionType_inside_record_functionType_named() async {
+    await resolveTestCode('''
+void f1(int i) {
+  f2((f: f3));
+}
+
+void f2(({int Function(int) f}) f) {}
+''');
+    await assertHasFix('''
+void f1(int i) {
+  f2((f: f3));
+}
+
+void f2(({int Function(int) f}) f) {}
+
+int f3(int p1) {
+}
+''');
+  }
+
   Future<void> test_functionType_notFunctionType() async {
     await resolveTestCode('''
 void f(A a) {

pkg/analysis_server/test/src/services/correction/fix/create_method_test.dart

@@ -837,6 +837,55 @@ class C {
 ''');
   }
 
+  Future<void> test_functionType_method_inside_record_functionType() async {
+    await resolveTestCode('''
+class C {
+  void m1(int i) {
+    m2((m3,));
+  }
+
+  void m2((int Function(int),) f) {}
+}
+''');
+    await assertHasFix('''
+class C {
+  void m1(int i) {
+    m2((m3,));
+  }
+
+  void m2((int Function(int),) f) {}
+
+  int m3(int p1) {
+  }
+}
+''');
+  }
+
+  Future<void>
+  test_functionType_method_inside_record_functionType_named() async {
+    await resolveTestCode('''
+class C {
+  void m1(int i) {
+    m2((f: m3));
+  }
+
+  void m2(({int Function(int) f}) f) {}
+}
+''');
+    await assertHasFix('''
+class C {
+  void m1(int i) {
+    m2((f: m3));
+  }
+
+  void m2(({int Function(int) f}) f) {}
+
+  int m3(int p1) {
+  }
+}
+''');
+  }
+
   Future<void> test_functionType_method_targetClass() async {
     await resolveTestCode('''
 void f(A a) {