make function-wrapping action wrap any uncalled function

plus a bunch more tests

Author: treuherz

compiler-core/src/language_server/code_action.rs

@@ -8279,41 +8279,46 @@ impl<'a> WrapInAnonymousFunction<'a> {
 }
 
 impl<'ast> ast::visit::Visit<'ast> for WrapInAnonymousFunction<'ast> {
-    fn visit_typed_call_arg(&mut self, arg: &'ast TypedCallArg) {
-        let function_range = src_span_to_lsp_range(arg.location, self.line_numbers);
-        if !overlaps(self.params.range, function_range) {
+    fn visit_typed_expr(&mut self, expression: &'ast TypedExpr) {
+        let expression_range = src_span_to_lsp_range(expression.location(), self.line_numbers);
+        if !overlaps(self.params.range, expression_range) {
             return;
         }
 
-        if let Type::Fn { ref arguments, .. } = *arg.value.type_() {
-            let variables_names = VariablesNames::from_expression(&arg.value);
-
+        if let Type::Fn { ref arguments, .. } = *expression.type_() {
             self.functions.push(FunctionToWrap {
-                location: arg.location,
+                location: expression.location(),
                 arguments: arguments.clone(),
-                variables_names,
+                variables_names: VariablesNames::from_expression(expression),
             });
-        }
-    }
+        };
 
-    fn visit_typed_assignment(&mut self, assignment: &'ast TypedAssignment) {
-        let function_range = src_span_to_lsp_range(assignment.location, self.line_numbers);
-        if !overlaps(self.params.range, function_range) {
-            return;
-        }
+        ast::visit::visit_typed_expr(self, expression);
+    }
 
-        if assignment.kind != AssignmentKind::Let {
-            return;
+    /// We don't want to apply to functions that are being explicitly called
+    /// already, so we need to intercept visits to function calls and bounce
+    /// them out again so they don't end up in our impl for visit_typed_expr.
+    /// Otherwise this is the same as [ast::visit::visit_typed_expr_call].
+    fn visit_typed_expr_call(
+        &mut self,
+        _location: &'ast SrcSpan,
+        _type: &'ast Arc<Type>,
+        fun: &'ast TypedExpr,
+        arguments: &'ast [TypedCallArg],
+    ) {
+        // We only need to do this interception for explicit calls, so if any
+        // of our arguments are explicit we re-enter the visitor as usual.
+        if arguments.iter().any(|a| a.is_implicit()) {
+            self.visit_typed_expr(fun);
+        } else {
+            // We still want to visit other nodes nested in the function being
+            // called so we bounce the call back out.
+            ast::visit::visit_typed_expr(self, fun);
         }
 
-        if let Type::Fn { ref arguments, .. } = *assignment.value.type_() {
-            let variables_names = VariablesNames::from_expression(&assignment.value);
-
-            self.functions.push(FunctionToWrap {
-                location: assignment.value.location(),
-                arguments: arguments.clone(),
-                variables_names,
-            });
+        for argument in arguments {
+            self.visit_typed_call_arg(argument);
         }
     }
 }
@@ -8387,7 +8392,7 @@ impl<'a> UnwrapAnonymousFunction<'a> {
     }
 
     /// If an anonymous function can be unwrapped, save it to our list
-    /// 
+    ///
     /// We need to ensure our subjects:
     /// - are anonymous function literals (not captures)
     /// - only contain a single statement
@@ -8460,11 +8465,11 @@ impl<'ast> ast::visit::Visit<'ast> for UnwrapAnonymousFunction<'ast> {
     fn visit_typed_expr_fn(
         &mut self,
         location: &'ast SrcSpan,
-        _type: &'ast Arc<Type>,
+        type_: &'ast Arc<Type>,
         kind: &'ast FunctionLiteralKind,
         arguments: &'ast [TypedArg],
         body: &'ast Vec1<TypedStatement>,
-        _return_annotation: &'ast Option<ast::TypeAst>,
+        return_annotation: &'ast Option<ast::TypeAst>,
     ) {
         let function_range = src_span_to_lsp_range(*location, self.line_numbers);
         if !overlaps(self.params.range, function_range) {
@@ -8473,8 +8478,14 @@ impl<'ast> ast::visit::Visit<'ast> for UnwrapAnonymousFunction<'ast> {
 
         self.register_function(location, kind, arguments, body);
 
-        for statement in body {
-            self.visit_typed_statement(statement);
-        }
+        ast::visit::visit_typed_expr_fn(
+            self,
+            location,
+            type_,
+            kind,
+            arguments,
+            body,
+            return_annotation,
+        )
     }
 }

compiler-core/src/language_server/tests/action.rs

@@ -9799,6 +9799,22 @@ fn remove_unreachable_branches_does_not_pop_up_if_all_branches_are_reachable() {
     );
 }
 
+#[test]
+fn wrap_uncalled_function_in_anonymous_function() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  op
+}
+
+fn op(i) {
+  todo
+}
+",
+        find_position_of("op").to_selection()
+    );
+}
+
 #[test]
 fn wrap_call_arg_in_anonymous_function() {
     assert_code_action!(
@@ -9817,6 +9833,22 @@ fn op(i: Int) -> Int {
     );
 }
 
+#[test]
+fn wrap_function_in_anonymous_function_without_shadowing() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  int
+}
+
+fn int(i: Int) {
+  todo
+}
+",
+        find_position_of("int").to_selection()
+    );
+}
+
 #[test]
 fn wrap_assignment_in_anonymous_function() {
     assert_code_action!(
@@ -9833,6 +9865,118 @@ fn op_factory(a: Int, b: Int, c: Int) -> fn(Int) -> Int {
     );
 }
 
+#[test]
+fn wrap_imported_function_in_anonymous_function() {
+    let source = "import gleam/list
+import gleam/int
+
+pub fn main() {
+  list.map([1, 2, 3], int.is_even)
+}
+";
+
+    let int_source = "pub fn is_even(int) { int % 2 == 0 }";
+
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        TestProject::for_source(source).add_module("gleam/int", int_source),
+        find_position_of("int.is_even").to_selection()
+    );
+}
+
+#[test]
+fn wrap_anonymous_function_in_anonymous_function() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  let f = fn(in) { ception(in) }
+}
+
+",
+        find_position_of("fn(in)").to_selection()
+    );
+}
+
+#[test]
+fn wrap_pipeline_step_in_anonymous_function() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  1 |> wibble |> wobble
+}
+
+fn wibble(i) {
+  todo
+}
+
+fn wobble(i) {
+  todo
+}
+
+",
+        find_position_of("wibble").to_selection()
+    );
+}
+
+#[test]
+fn wrap_final_pipeline_step_in_anonymous_function() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  1 |> wibble |> wobble
+}
+
+fn wibble(i) {
+  todo
+}
+
+fn wobble(i) {
+  todo
+}
+
+",
+        find_position_of("wobble").to_selection()
+    );
+}
+
+#[test]
+fn wrap_record_field_in_anonymous_function() {
+    assert_code_action!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  let r = Record(wibble)
+}
+
+type Record {
+  Record(wibbler: fn(Int) -> Int)
+}
+
+fn wibble(v) {
+  todo
+}
+
+",
+        find_position_of("wibble").to_selection()
+    );
+}
+
+#[test]
+fn dont_wrap_functions_that_are_already_being_called() {
+    assert_no_code_actions!(
+        WRAP_IN_ANONYMOUS_FUNCTION,
+        "pub fn main() {
+  wibble(1)
+}
+
+fn wibble(i) {
+  todo
+}
+
+",
+        find_position_of("wibble").to_selection()
+    );
+}
+
 #[test]
 fn unwrap_trivial_anonymous_function() {
     assert_code_action!(
@@ -9892,7 +10036,7 @@ fn unwrap_anonymous_function_unavailable_with_different_args() {
         "import gleam/list
 
 const another_int = 7
-        
+
 pub fn main() {
   list.map([1, 2, 3], fn(int) { op(another_int) })
 }

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__wrap_anonymous_function_in_anonymous_function.snap

@@ -0,0 +1,16 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "pub fn main() {\n  let f = fn(in) { ception(in) }\n}\n\n"
+---
+----- BEFORE ACTION
+pub fn main() {
+  let f = fn(in) { ception(in) }
+          ↑                     
+}
+
+
+
+----- AFTER ACTION
+pub fn main() {
+  let f = fn(value) { fn(in) { ception(in) }(value) }
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__wrap_final_pipeline_step_in_anonymous_function.snap

@@ -0,0 +1,32 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "pub fn main() {\n  1 |> wibble |> wobble\n}\n\nfn wibble(i) {\n  todo\n}\n\nfn wobble(i) {\n  todo\n}\n\n"
+---
+----- BEFORE ACTION
+pub fn main() {
+  1 |> wibble |> wobble
+                 ↑     
+}
+
+fn wibble(i) {
+  todo
+}
+
+fn wobble(i) {
+  todo
+}
+
+
+
+----- AFTER ACTION
+pub fn main() {
+  1 |> wibble |> fn(value) { wobble(value) }
+}
+
+fn wibble(i) {
+  todo
+}
+
+fn wobble(i) {
+  todo
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__wrap_function_in_anonymous_function_without_shadowing.snap

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "pub fn main() {\n  int\n}\n\nfn int(i: Int) {\n  todo\n}\n"
+---
+----- BEFORE ACTION
+pub fn main() {
+  int
+  ↑  
+}
+
+fn int(i: Int) {
+  todo
+}
+
+
+----- AFTER ACTION
+pub fn main() {
+  fn(int_2) { int(int_2) }
+}
+
+fn int(i: Int) {
+  todo
+}

compiler-core/src/language_server/tests/snapshots/gleam_core__language_server__tests__action__wrap_imported_function_in_anonymous_function.snap

@@ -0,0 +1,21 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "import gleam/list\nimport gleam/int\n\npub fn main() {\n  list.map([1, 2, 3], int.is_even)\n}\n"
+---
+----- BEFORE ACTION
+import gleam/list
+import gleam/int
+
+pub fn main() {
+  list.map([1, 2, 3], int.is_even)
+                      ↑           
+}
+
+
+----- AFTER ACTION
+import gleam/list
+import gleam/int
+
+pub fn main() {
+  list.map([1, 2, 3], fn(int) { int.is_even(int) })
+}