use correct location for extracted uses

Author: giacomocavalieri

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Bug fixes
+
+- Fixed a bug where the "Extract function" code action would not properly
+  extract 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

@@ -8981,11 +8981,24 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
     }
 
     fn visit_typed_statement(&mut self, statement: &'ast TypedStatement) {
-        let location = statement.location();
-        if self.can_extract(location) {
-            let position = if let Some(last_statement_location) = self.last_statement_location
-                && location == last_statement_location
-            {
+        let statement_location = match statement {
+            ast::Statement::Expression(expression) => expression.location(),
+            ast::Statement::Assignment(assignment) => assignment.location,
+            ast::Statement::Assert(assert) => assert.location,
+            ast::Statement::Use(use_) => use_.location.merge(&use_.call.location()),
+        };
+
+        if self.can_extract(statement_location) {
+            let is_in_tail_position =
+                self.last_statement_location
+                    .is_some_and(|last_statement_location| {
+                        last_statement_location == statement_location
+                    });
+
+            // A use is always eating up the entire block, if we're extracting it,
+            // it will be in tail position there and the extracted function should
+            // return its returned value.
+            let position = if statement.is_use() || is_in_tail_position {
                 StatementPosition::Tail {
                     type_: statement.type_(),
                 }
@@ -8996,7 +9009,7 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
             match &mut self.function {
                 None => {
                     self.function = Some(ExtractedFunction::new(ExtractedValue::Statements {
-                        location,
+                        location: statement_location,
                         position,
                     }));
                 }
@@ -9008,8 +9021,8 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
                     ..
                 }) => {}
                 // If we are selecting multiple statements, this statement should
-                // be included within list, so we merge th spans to ensure it is
-                // included.
+                // be included within list, so we merge the spans to ensure it
+                // is included.
                 Some(ExtractedFunction {
                     value:
                         ExtractedValue::Statements {
@@ -9018,7 +9031,7 @@ impl<'ast> ast::visit::Visit<'ast> for ExtractFunction<'ast> {
                         },
                     ..
                 }) => {
-                    *location = location.merge(&statement.location());
+                    *location = location.merge(&statement_location);
                     *extracted_position = position;
                 }
             }

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

@@ -10554,3 +10554,20 @@ pub fn main() {
         find_position_of("let c").select_until(find_position_of("* d"))
     );
 }
+
+#[test]
+fn extract_use_in_tail_position() {
+    assert_code_action!(
+        EXTRACT_FUNCTION,
+        r#"
+pub fn main() {
+  use <- wibble
+  123
+}
+
+fn wibble(f: fn() -> Int) -> Int { f() }
+"#,
+        find_position_of("use").select_until(find_position_of("wibble"))
+    );
+}
+

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

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