[DAS] Fixes types for convert to function declaration

Fixes: #60633
Change-Id: I97d7aa1018343d3435d019cb5c3a2605b840d8f2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/425020
Auto-Submit: Felipe Morschel <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Reviewed-by: Ivan Inozemtsev <[email protected]>
Commit-Queue: Ivan Inozemtsev <[email protected]>

Author: FMorschel

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

@@ -4,8 +4,11 @@
 
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server_plugin/edit/dart/correction_producer.dart';
-import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/source/source_range.dart';
+import 'package:analyzer/src/dart/ast/ast.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';
@@ -54,7 +57,7 @@ class ConvertToFunctionDeclaration extends ResolvedCorrectionProducer {
           if (before != null) {
             builder.write(before);
           }
-          builder.write(utils.endOfLine);
+          builder.write(eol);
           builder.write(utils.getLinePrefix(range.offset));
           if (after != null) {
             builder.write(after);
@@ -77,8 +80,63 @@ class ConvertToFunctionDeclaration extends ResolvedCorrectionProducer {
         replaceWithNewLine(r, before: ';');
       }
 
+      DartType? returnType;
+      List<FormalParameterElement?>? parameterList;
+      if (type case NamedType(
+        element2: TypeAliasElement(:GenericFunctionTypeElement aliasedElement2),
+      )) {
+        returnType = aliasedElement2.returnType;
+        parameterList = aliasedElement2.formalParameters;
+      } else if (type is GenericFunctionType) {
+        returnType = type.returnType?.type;
+        parameterList =
+            type.parameters.parameters
+                .map((node) => node.declaredFragment!.element)
+                .toList();
+      } else if (initializer case FunctionExpression(
+        declaredFragment: ExecutableFragment(:var element),
+        :var body,
+      )) {
+        returnType = element.returnType;
+        var visitor = _ReturnVisitor();
+        body.accept(visitor);
+        if (visitor.noReturnFounds) {
+          if (typeProvider.nullType == element.returnType) {
+            returnType = typeProvider.voidType;
+          } else if (typeProvider.futureNullType == element.returnType) {
+            returnType = typeProvider.futureType(typeProvider.voidType);
+          }
+        }
+      }
+
+      if (builder.canWriteType(returnType)) {
+        builder.addInsertion(node.offset, (builder) {
+          builder.writeType(returnType);
+          builder.write(' ');
+        });
+      }
+
       builder.addDeletion(range.endStart(equals.previous!, equals.next!));
 
+      if (parameterList != null) {
+        var staticParameters = parameterList;
+        if (initializer case FunctionExpression(:var parameters?)) {
+          for (var (index, parameter) in parameters.parameters.indexed) {
+            if (parameter.isExplicitlyTyped) {
+              continue;
+            }
+            var staticParameterType = staticParameters[index]?.type;
+            if (!builder.canWriteType(staticParameterType)) {
+              continue;
+            }
+            builder.addInsertion(parameter.offset, (builder) {
+              builder.writeType(staticParameterType);
+              builder.write(' ');
+            });
+          }
+        }
+      }
+
       if (next != null) {
         var r = range.endStart(node.endToken, node.endToken.next!.next!);
         if (next.initializer is FunctionExpression) {
@@ -116,3 +174,25 @@ class ConvertToFunctionDeclaration extends ResolvedCorrectionProducer {
     return i > 0 ? variables[i - 1] : null;
   }
 }
+
+class _ReturnVisitor extends RecursiveAstVisitor<void> {
+  int _count = 0;
+  bool get noReturnFounds => _count == 0;
+
+  @override
+  void visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    _count++;
+    super.visitExpressionFunctionBody(node);
+  }
+
+  @override
+  void visitFunctionExpression(FunctionExpression node) {
+    // Inner function expressions are not counted.
+  }
+
+  @override
+  void visitReturnStatement(ReturnStatement node) {
+    _count++;
+    super.visitReturnStatement(node);
+  }
+}

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

@@ -34,8 +34,8 @@ void f() {
 ''');
     await assertHasFix('''
 void f() {
-  v1() {}
-  v2() {}
+  void v1() {}
+  void v2() {}
   v1();
   v2();
 }
@@ -52,8 +52,8 @@ void f() {
 ''');
     await assertHasFix('''
 void f() {
-  v1() {}
-  v2() {}
+  void v1() {}
+  void v2() {}
   v1();
   v2();
 }
@@ -80,8 +80,8 @@ void f() {
     expect(fixes, hasLength(1));
     assertProduces(fixes.first, '''
 void f() {
-  v() {
-    v() {}
+  void v() {
+    void v() {}
     v();
   }
   v();
@@ -107,7 +107,7 @@ void f() {
 ''');
     await assertHasFix('''
 void f() {
-  v() {}
+  void v() {}
   v();
 }
 ''');
@@ -123,7 +123,7 @@ void f() {
     await assertHasFix('''
 void f() {
   final v1 = 1;
-  v2(x, y) {}
+  void v2(x, y) {}
   final v3 = '';
   v2(v1, v3);
 }
@@ -139,12 +139,92 @@ void f() {
 ''');
     await assertHasFix('''
 void f() {
-  v() => 3;
+  int v() => 3;
   v();
 }
 ''');
   }
 
+  Future<void> test_functionTypedParameter() async {
+    await resolveTestCode('''
+void f() {
+  int Function(int Function(String)?) v1 = (p) {
+    return p?.call('') ?? 0;
+  };
+  v1((s) => 0);
+}
+''');
+    await assertHasFix('''
+void f() {
+  int v1(int Function(String p1)? p) {
+    return p?.call('') ?? 0;
+  }
+  v1((s) => 0);
+}
+''');
+  }
+
+  Future<void> test_futureIntBody() async {
+    await resolveTestCode('''
+void f() {
+  final v1 = () async {
+    return 0;
+  };
+  v1();
+}
+''');
+    await assertHasFix('''
+void f() {
+  Future<int> v1() async {
+    return 0;
+  }
+  v1();
+}
+''');
+  }
+
+  Future<void> test_futureVoid() async {
+    await resolveTestCode('''
+void f() {
+  final v1 = () async {
+  };
+  v1();
+}
+''');
+    await assertHasFix('''
+void f() {
+  Future<void> v1() async {
+  }
+  v1();
+}
+''');
+  }
+
+  Future<void> test_innerFunctions() async {
+    await resolveTestCode('''
+void f() {
+  final v1 = () {
+    () {
+      return 0;
+    };
+    () => 0;
+  };
+  v1();
+}
+''');
+    await assertHasFix('''
+void f() {
+  void v1() {
+    () {
+      return 0;
+    };
+    () => 0;
+  }
+  v1();
+}
+''');
+  }
+
   Future<void> test_no_initializer() async {
     await resolveTestCode('''
 typedef F = void Function();
@@ -160,7 +240,7 @@ void f() {
 typedef F = void Function();
 
 void f() {
-  g() {}
+  void g() {}
   final F h;
   g();
   h = () {};
@@ -178,9 +258,68 @@ void f() {
 ''');
     await assertHasFix('''
 void f() {
-  v() => throw '';
+  String v() => throw '';
   v();
 }
+''');
+  }
+
+  Future<void> test_typedefTyped() async {
+    await resolveTestCode('''
+typedef T = int Function(int);
+
+void f() {
+  T v1 = (p) {
+    return p;
+  };
+  v1(0);
+}
+''');
+    await assertHasFix('''
+typedef T = int Function(int);
+
+void f() {
+  int v1(int p) {
+    return p;
+  }
+  v1(0);
+}
+''');
+  }
+
+  Future<void> test_typeParameter() async {
+    await resolveTestCode('''
+void f() {
+  final v1 = <T>(T p) {
+  };
+  v1(0);
+}
+''');
+    await assertHasFix('''
+void f() {
+  void v1<T>(T p) {
+  }
+  v1(0);
+}
+''');
+  }
+
+  Future<void> test_variableTyped() async {
+    await resolveTestCode('''
+void f() {
+  int Function(int) v1 = (p) {
+    return p;
+  };
+  v1(0);
+}
+''');
+    await assertHasFix('''
+void f() {
+  int v1(int p) {
+    return p;
+  }
+  v1(0);
+}
 ''');
   }
 }