use correct type for extracted nested use

Author: giacomocavalieri

CHANGELOG.md

@@ -8,6 +8,10 @@
   extract a `use` expression.
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- Fixed a bug where the "Extract function" code action would generate a function
+  with the wrong type when used on a use expression.
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ## v1.13.0-rc1 - 2025-09-29
 
 ### Compiler

compiler-core/src/language_server/code_action.rs

@@ -8635,13 +8635,23 @@ impl<'a> ExtractFunction<'a> {
                     end,
                 )
             }
-            ExtractedValue::Expression(expression) => self.extract_code_in_tail_position(
-                expression.location(),
-                expression.location(),
-                expression.type_(),
-                extracted.parameters,
-                end,
-            ),
+            ExtractedValue::Expression(expression) => {
+                let expression_type = match expression {
+                    TypedExpr::Fn {
+                        type_,
+                        kind: FunctionLiteralKind::Use { .. },
+                        ..
+                    } => type_.fn_types().expect("use callback to be a function").1,
+                    _ => expression.type_(),
+                };
+                self.extract_code_in_tail_position(
+                    expression.location(),
+                    expression.location(),
+                    expression_type,
+                    extracted.parameters,
+                    end,
+                )
+            }
             ExtractedValue::Statements {
                 location,
                 position: StatementPosition::NotTail,

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

@@ -10571,3 +10571,22 @@ fn wibble(f: fn() -> Int) -> Int { f() }
     );
 }
 
+#[test]
+fn extract_use_in_tail_position_2() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+pub fn main() {
+  use <- wibble
+  use <- wobble
+  123
+}
+
+fn wibble(f: fn() -> Float) -> Float { f() }
+fn wobble(f: fn() -> Int) -> Float { 1.1 }
+"#,
+        find_position_of("use")
+            .nth_occurrence(2)
+            .select_until(find_position_of("wobble"))
+    );
+}

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

@@ -0,0 +1,31 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  use <- wibble\n  use <- wobble\n  123\n}\n\nfn wibble(f: fn() -> Float) -> Float { f() }\nfn wobble(f: fn() -> Int) -> Float { 1.1 }\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  use <- wibble
+  use <- wobble
+  ▔▔▔▔▔▔▔↑     
+  123
+}
+
+fn wibble(f: fn() -> Float) -> Float { f() }
+fn wobble(f: fn() -> Int) -> Float { 1.1 }
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  use <- wibble
+  function()
+}
+
+fn function() -> Float {
+  use <- wobble
+  123
+}
+
+fn wibble(f: fn() -> Float) -> Float { f() }
+fn wobble(f: fn() -> Int) -> Float { 1.1 }