expand underscore

Author: giacomocavalieri

CHANGELOG.md

@@ -184,8 +184,8 @@
 
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
-- The "pattern match on variable" can now be triggered on variables introduced
-  by other patterns. For example:
+- The "pattern match on variable" code action can now be triggered on variables
+  introduced by other patterns. For example:
 
   ```gleam
   pub fn main() {
@@ -209,6 +209,36 @@
 
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- The "pattern match on variable" code action can now be triggered on variables
+  in case expressions. For example:
+
+  ```gleam
+  pub fn main() {
+    case find_user() {
+      Ok(user) -> todo
+      Error(_) -> todo
+    }
+  }
+  ```
+
+  Triggering the action over the `user` variable would result in the following
+  code:
+
+  ```gleam
+  pub fn main() {
+    case find_user() {
+      Ok(user) ->
+        case user {
+          Admin -> todo
+          Member -> todo
+        }
+      Error(_) -> todo
+    }
+  }
+  ```
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 - The language server now offers a quick fix to remove `opaque` from a private
   type:
 

compiler-core/src/language_server/code_action.rs

@@ -4353,6 +4353,20 @@ pub enum PatternMatchedValue<'a> {
         ///
         assignment_location: SrcSpan,
     },
+    /// A variable that is bound in a case branch's pattern. For example:
+    /// ```gleam
+    /// case wibble {
+    ///   wobble -> 1
+    /// // ^^^^^ This!
+    /// }
+    /// ```
+    ///
+    ClausePatternVariable {
+        variable_name: &'a EcoString,
+        variable_type: Arc<Type>,
+        clause_body_location: SrcSpan,
+        clause_location: SrcSpan,
+    },
     UseVariable {
         variable_name: &'a EcoString,
         variable_type: Arc<Type>,
@@ -4411,6 +4425,21 @@ where
                 "Pattern match on variable"
             }
 
+            Some(PatternMatchedValue::ClausePatternVariable {
+                variable_name,
+                variable_type,
+                clause_body_location,
+                clause_location,
+            }) => {
+                self.match_on_clause_variable(
+                    variable_name,
+                    variable_type,
+                    clause_body_location,
+                    clause_location,
+                );
+                "Pattern match on variable"
+            }
+
             None => return vec![],
         };
 
@@ -4523,6 +4552,34 @@ where
         );
     }
 
+    fn match_on_clause_variable(
+        &mut self,
+        variable_name: &EcoString,
+        variable_type: Arc<Type>,
+        clause_body_location: SrcSpan,
+        clause_location: SrcSpan,
+    ) {
+        let Some(patterns) = self.type_to_destructure_patterns(variable_type.as_ref()) else {
+            return;
+        };
+
+        let body_code = code_at(self.module, clause_body_location);
+
+        let clause_range = self.edits.src_span_to_lsp_range(clause_location);
+        let nesting = " ".repeat(2 + clause_range.start.character as usize);
+
+        let patterns = patterns
+            .iter()
+            .map(|p| format!("  {nesting}{p} -> {body_code}"))
+            .join("\n");
+        let pattern_matching = format!("case {variable_name} {{\n{patterns}\n{nesting}}}");
+
+        self.edits.replace(
+            clause_body_location,
+            format!("\n{nesting}{pattern_matching}"),
+        );
+    }
+
     /// Will produce a pattern that can be used on the left hand side of a let
     /// assignment to destructure a value of the given type. For example given
     /// this type:
@@ -4761,6 +4818,28 @@ where
         }
     }
 
+    fn visit_typed_clause(&mut self, clause: &'ast ast::TypedClause) {
+        for pattern in clause.pattern.iter() {
+            self.visit_typed_pattern(pattern);
+        }
+        for patterns in clause.alternative_patterns.iter() {
+            for pattern in patterns {
+                self.visit_typed_pattern(pattern);
+            }
+        }
+
+        if let Some((name, type_)) = self.pattern_variable_under_cursor.take() {
+            self.selected_value = Some(PatternMatchedValue::ClausePatternVariable {
+                variable_name: name,
+                variable_type: type_,
+                clause_body_location: clause.then.location(),
+                clause_location: clause.location(),
+            });
+        } else {
+            self.visit_typed_expr(&clause.then);
+        }
+    }
+
     fn visit_typed_use(&mut self, use_: &'ast TypedUse) {
         if let Some(assignments) = use_.callback_arguments() {
             for variable in assignments {

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

@@ -6967,6 +6967,57 @@ pub fn main() {
     );
 }
 
+#[test]
+fn pattern_match_on_clause_variable() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> 1
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }
+
+",
+        find_position_of("something").to_selection()
+    );
+}
+
+#[test]
+fn pattern_match_on_clause_variable_with_block_body() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> {
+      1
+      2
+    }
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }
+
+",
+        find_position_of("something").to_selection()
+    );
+}
+
 #[test]
 fn pattern_match_on_argument_will_use_qualified_name() {
     let src = "

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

@@ -0,0 +1,42 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  case maybe_wibble() {\n    Ok(something) -> 1\n    Error(_) -> 2\n  }\n}\n\ntype Wibble {\n  Wobble\n  Woo\n}\n\nfn maybe_wibble() { Ok(Wobble) }\n\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> 1
+       ↑              
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }
+
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> 
+      case something {
+        Wobble -> 1
+        Woo -> 1
+      }
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }

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

@@ -0,0 +1,51 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "\npub fn main() {\n  case maybe_wibble() {\n    Ok(something) -> {\n      1\n      2\n    }\n    Error(_) -> 2\n  }\n}\n\ntype Wibble {\n  Wobble\n  Woo\n}\n\nfn maybe_wibble() { Ok(Wobble) }\n\n"
+---
+----- BEFORE ACTION
+
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> {
+       ↑              
+      1
+      2
+    }
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }
+
+
+
+----- AFTER ACTION
+
+pub fn main() {
+  case maybe_wibble() {
+    Ok(something) -> 
+      case something {
+        Wobble -> {
+      1
+      2
+    }
+        Woo -> {
+      1
+      2
+    }
+      }
+    Error(_) -> 2
+  }
+}
+
+type Wibble {
+  Wobble
+  Woo
+}
+
+fn maybe_wibble() { Ok(Wobble) }