allow 'pattern match on variable' on use variables

CHANGELOG.md

···
 
 ### Language server
 
+- It is now possible to use the "Pattern match on variable" code action on
+  variables on the left hand side of a `use`. For example:
+
+  ```gleam
+  pub type User {
+    User(id: Int, name: String)
+  }
+
+  pub fn main() {
+    use user <- result.try(load_user())
+    //  ^^^^ Triggering the code action here
+    todo
+  }
+  ```
+
+  Would result in the following code:
+
+  ```gleam
+  pub type User {
+    User(id: Int, name: String)
+  }
+
+  pub fn main() {
+    use user <- result.try(load_user())
+    let User(id:, name:) = user
+    todo
+  }
+  ```
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ### Formatter
 
 - The formatter now allows more control over how lists are split. By adding a

compiler-core/src/ast.rs

···
         }
         self.call.find_node(byte_index)
     }
+
+    pub fn callback_arguments<'a>(&'a self) -> Option<&'a Vec<TypedArg>> {
+        let TypedExpr::Call { args, .. } = self.call.as_ref() else {
+            return None;
+        };
+        let callback = args.iter().last()?;
+        let TypedExpr::Fn { args, .. } = &callback.value else {
+            // The expression might be invalid so we have to return a None here
+            return None;
+        };
+        Some(args)
+    }
 }
 
 pub type TypedStatement = Statement<Arc<Type>, TypedExpr>;

compiler-core/src/language_server/code_action.rs

···
 use crate::{
     Error, STDLIB_PACKAGE_NAME, analyse,
     ast::{
-        self, AssignName, AssignmentKind, BitArraySegmentTruncation, CallArg, CustomType,
+        self, ArgNames, AssignName, AssignmentKind, BitArraySegmentTruncation, CallArg, CustomType,
         FunctionLiteralKind, ImplicitCallArgOrigin, Import, PIPE_PRECEDENCE, Pattern,
         PatternUnusedArguments, PipelineAssignmentKind, RecordConstructor, SrcSpan, TodoKind,
         TypedArg, TypedAssignment, TypedExpr, TypedModuleConstant, TypedPattern,
···
         ///
         assignment_location: SrcSpan,
     },
+    UseVariable {
+        variable_name: &'a EcoString,
+        variable_type: &'a Arc<Type>,
+        /// The location of the entire use expression the variable is part of,
+        /// so that we can add the pattern matching _after_ it.
+        ///
+        use_location: SrcSpan,
+    },
 }
 
 impl<'a, IO> PatternMatchOnValue<'a, IO>
···
             Some(PatternMatchedValue::LetVariable {
                 variable_name,
                 variable_type,
-                assignment_location,
+                assignment_location: location,
+            })
+            | Some(PatternMatchedValue::UseVariable {
+                variable_name,
+                variable_type,
+                use_location: location,
             }) => {
-                self.match_on_let_variable(variable_name, variable_type, assignment_location);
+                self.match_on_let_variable(variable_name, variable_type, location);
                 "Pattern match on variable"
             }
             None => return vec![],
···
         }
 
         ast::visit::visit_typed_assignment(self, assignment);
+    }
+
+    fn visit_typed_use(&mut self, use_: &'ast TypedUse) {
+        if let Some(assignments) = use_.callback_arguments() {
+            for variable in assignments {
+                let ast::Arg {
+                    names: ArgNames::Named { name, .. },
+                    location: variable_location,
+                    type_,
+                    ..
+                } = variable
+                else {
+                    continue;
+                };
+
+                // If we use a pattern in a use assignment, that will end up
+                // being called `_use` something. We don't want to offer the
+                // action when hovering a pattern so we ignore those.
+                if name.starts_with("_use") {
+                    continue;
+                }
+
+                let variable_range = self.edits.src_span_to_lsp_range(*variable_location);
+                if within(self.params.range, variable_range) {
+                    self.selected_value = Some(PatternMatchedValue::UseVariable {
+                        variable_name: name,
+                        variable_type: type_,
+                        use_location: use_.location,
+                    });
+                    // If we've found the variable to pattern match on, there's no
+                    // point in keeping traversing the AST.
+                    return;
+                }
+            }
+        }
+
+        ast::visit::visit_typed_use(self, use_);
     }
 }
 

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

···
 }
 
 #[test]
+fn pattern_match_on_use_assignment() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  use var <- f
+}
+
+fn f(g) { g(#(1, 2)) }
+",
+        find_position_of("var").to_selection()
+    );
+}
+
+#[test]
+fn pattern_match_on_use_assignment_with_multiple_constructors() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub type Wibble {
+  Wobble
+  Woo
+}
+
+pub fn main() {
+  use var <- f
+}
+
+fn f(g) { g(Wobble) }
+",
+        find_position_of("var").to_selection()
+    );
+}
+
+#[test]
+fn pattern_match_on_pattern_use_assignment() {
+    assert_no_code_actions!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  use #(a, b) <- f
+}
+
+fn f(g) { g(#(1, 2)) }
+",
+        find_position_of("#").to_selection()
+    );
+}
+
+#[test]
 fn pattern_match_on_argument_works_on_fn_arguments() {
     assert_code_action!(
         PATTERN_MATCH_ON_ARGUMENT,

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

···
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  use var <- f\n}\n\nfn f(g) { g(#(1, 2)) }\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  use var <- f
+      ↑       
+}
+
+fn f(g) { g(#(1, 2)) }
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  use var <- f
+  let #(value_0, value_1) = var
+}
+
+fn f(g) { g(#(1, 2)) }

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

···
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub type Wibble {\n  Wobble\n  Woo\n}\n\npub fn main() {\n  use var <- f\n}\n\nfn f(g) { g(Wobble) }\n"
+---
+----- BEFORE ACTION
+
+pub type Wibble {
+  Wobble
+  Woo
+}
+
+pub fn main() {
+  use var <- f
+      ↑       
+}
+
+fn f(g) { g(Wobble) }
+
+
+----- AFTER ACTION
+
+pub type Wibble {
+  Wobble
+  Woo
+}
+
+pub fn main() {
+  use var <- f
+  case var {
+    Wobble -> todo
+    Woo -> todo
+  }
+}
+
+fn f(g) { g(Wobble) }