add collapse case code action

Author: giacomocavalieri

CHANGELOG.md

@@ -234,6 +234,39 @@
   colon in the rename dialog (`name:` -> `name`)
   ([fruno](https://github.com/frunobulax-the-poodle))
 
+- The language server now offers a code action to collapse nested case
+  expressions. Take this example:
+
+  ```gleam
+  case user {
+    User(role: Admin, name:) ->
+      // Here the only thing we're doing is pattern matching on the
+      // `name` variable we've just defined in the outer pattern.
+      case name {
+        "Joe" -> "Hello, Joe!"
+        _ -> "Hello, stranger"
+      }
+
+    _ -> "You're not an admin!"
+  }
+  ```
+
+  We could simplify this case expression and reduce nesting like so:
+
+  ```gleam
+  case user {
+    User(role: Admin, name: "Joe") -> "Hello, Joe!"
+    User(role: Admin, name: _) -> "Hello, stranger"
+    _ -> "You're not an admin!"
+  }
+  ```
+
+  Now, if you hover over that pattern, the language server will offer the
+  "collapse nested case" action that will simplify your code like shown in the
+  example above.
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 ### Formatter
 
 - The formatter now removes needless multiple negations that are safe to remove.

compiler-core/src/ast.rs

@@ -2707,24 +2707,28 @@ impl TypedPattern {
         }
     }
 
-    pub fn bound_variables(&self) -> Vec<EcoString> {
+    pub fn bound_variables(&self) -> Vec<(EcoString, SrcSpan)> {
         let mut variables = Vec::new();
         self.collect_bound_variables(&mut variables);
         variables
     }
 
-    fn collect_bound_variables(&self, variables: &mut Vec<EcoString>) {
+    fn collect_bound_variables(&self, variables: &mut Vec<(EcoString, SrcSpan)>) {
         match self {
             Pattern::Int { .. }
             | Pattern::Float { .. }
             | Pattern::String { .. }
             | Pattern::Discard { .. }
             | Pattern::Invalid { .. } => {}
 
-            Pattern::Variable { name, .. } => variables.push(name.clone()),
+            Pattern::Variable { name, location, .. } => variables.push((name.clone(), *location)),
             Pattern::BitArraySize { .. } => {}
-            Pattern::Assign { name, pattern, .. } => {
-                variables.push(name.clone());
+            Pattern::Assign {
+                name,
+                pattern,
+                location,
+            } => {
+                variables.push((name.clone(), *location));
                 pattern.collect_bound_variables(variables);
             }
             Pattern::List { elements, tail, .. } => {
@@ -2753,13 +2757,14 @@ impl TypedPattern {
             Pattern::StringPrefix {
                 left_side_assignment,
                 right_side_assignment,
+                right_location,
                 ..
             } => {
-                if let Some((left_variable, _)) = left_side_assignment {
-                    variables.push(left_variable.clone());
+                if let Some(assignment) = left_side_assignment {
+                    variables.push(assignment.clone());
                 }
                 match right_side_assignment {
-                    AssignName::Variable(name) => variables.push(name.clone()),
+                    AssignName::Variable(name) => variables.push((name.clone(), *right_location)),
                     AssignName::Discard(_) => {}
                 }
             }

compiler-core/src/javascript/decision.rs

@@ -702,7 +702,7 @@ pub fn let_<'a>(
     // We must generate this after we generate the code for the decision tree
     // itself as we might be re-binding variables which are used in the checks
     // to determine whether the pattern matches or not.
-    let beginning_assignments = pattern.bound_variables().into_iter().map(|variable| {
+    let beginning_assignments = pattern.bound_variables().into_iter().map(|(variable, _)| {
         docvec![
             "let ",
             expression_generator.local_var(&variable),