add "Remove unreachable branches" code action

Author: giacomocavalieri

CHANGELOG.md

@@ -162,6 +162,37 @@
 
 ### Language server
 
+- The language server now offers a code action to remove all the unreachable
+  branches in a case expression. For example:
+
+  ```gleam
+  pub fn main() {
+    case find_user() {
+      Ok(user) -> todo
+      Ok(Admin) -> todo
+  //  ^^^^^^^^^ This branch is unreachable
+      Ok(User) -> todo
+  //  ^^^^^^^^ This branch is unreachable
+      Error(_) -> todo
+    }
+  }
+  ```
+
+  Hovering over one of the unreachable branches and triggering the code action
+  would remove all the unreachable branches:
+
+  ```gleam
+  pub fn main() {
+    case find_user() {
+      Ok(user) -> todo
+
+      Error(_) -> todo
+    }
+  }
+  ```
+
+  ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
 - The "pattern match on variable" can now be triggered on lists. For example:
 
   ```gleam

compiler-core/src/language_server/code_action.rs

@@ -8106,3 +8106,93 @@ fn single_expression(expression: &TypedExpr) -> Option<&TypedExpr> {
         expression => Some(expression),
     }
 }
+
+/// Code action to remove `opaque` from a private type.
+///
+pub struct RemoveUnreachableBranches<'a> {
+    module: &'a Module,
+    params: &'a CodeActionParams,
+    edits: TextEdits<'a>,
+    /// The source location of the patterns of all the unreachable branches in
+    /// the current module.
+    ///
+    unreachable_branches: HashSet<SrcSpan>,
+    branches_to_delete: Vec<SrcSpan>,
+}
+
+impl<'a> RemoveUnreachableBranches<'a> {
+    pub fn new(
+        module: &'a Module,
+        line_numbers: &'a LineNumbers,
+        params: &'a CodeActionParams,
+    ) -> Self {
+        let unreachable_branches = (module.ast.type_info.warnings.iter())
+            .filter_map(|warning| match warning {
+                type_::Warning::UnreachableCasePattern { location, .. } => Some(*location),
+                _ => None,
+            })
+            .collect();
+
+        Self {
+            unreachable_branches,
+            module,
+            params,
+            edits: TextEdits::new(line_numbers),
+            branches_to_delete: vec![],
+        }
+    }
+
+    pub fn code_actions(mut self) -> Vec<CodeAction> {
+        self.visit_typed_module(&self.module.ast);
+        if self.branches_to_delete.is_empty() {
+            return vec![];
+        }
+
+        for branch in self.branches_to_delete {
+            self.edits.delete(branch);
+        }
+
+        let mut action = Vec::with_capacity(1);
+        CodeActionBuilder::new("Remove unreachable branches")
+            .kind(CodeActionKind::QUICKFIX)
+            .changes(self.params.text_document.uri.clone(), self.edits.edits)
+            .preferred(true)
+            .push_to(&mut action);
+        action
+    }
+}
+
+impl<'ast> ast::visit::Visit<'ast> for RemoveUnreachableBranches<'ast> {
+    fn visit_typed_expr_case(
+        &mut self,
+        location: &'ast SrcSpan,
+        type_: &'ast Arc<Type>,
+        subjects: &'ast [TypedExpr],
+        clauses: &'ast [ast::TypedClause],
+        compiled_case: &'ast CompiledCase,
+    ) {
+        // We're showing the code action only if we're within one of the
+        // unreachable patterns. And the code action is going to remove all the
+        // unreachable patterns for this case.
+        let is_hovering_clause = clauses.iter().any(|clause| {
+            let pattern_range = self.edits.src_span_to_lsp_range(clause.pattern_location());
+            within(self.params.range, pattern_range)
+        });
+        if is_hovering_clause {
+            self.branches_to_delete = clauses
+                .iter()
+                .filter(|clause| {
+                    self.unreachable_branches
+                        .contains(&clause.pattern_location())
+                })
+                .map(|clause| clause.location())
+                .collect_vec();
+            return;
+        }
+
+        // If we're not hovering any of the branches clauses then we want to
+        // keep visiting the case expression as the unreachable branch might be
+        // in one of the nested cases.
+        ast::visit::visit_typed_expr_case(self, location, type_, subjects, clauses, compiled_case);
+    }
+}

compiler-core/src/language_server/engine.rs

@@ -12,7 +12,9 @@ use crate::{
     config::PackageConfig,
     io::{BeamCompiler, CommandExecutor, FileSystemReader, FileSystemWriter},
     language_server::{
-        code_action::{CollapseNestedCase, RemoveBlock, RemovePrivateOpaque},
+        code_action::{
+            CollapseNestedCase, RemoveBlock, RemovePrivateOpaque, RemoveUnreachableBranches,
+        },
         compiler::LspProjectCompiler,
         files::FileSystemProxy,
         progress::ProgressReporter,
@@ -404,6 +406,7 @@ where
             code_action_fix_names(&lines, &params, &this.error, &mut actions);
             code_action_import_module(module, &lines, &params, &this.error, &mut actions);
             code_action_add_missing_patterns(module, &lines, &params, &this.error, &mut actions);
+            actions.extend(RemoveUnreachableBranches::new(module, &lines, &params).code_actions());
             actions.extend(CollapseNestedCase::new(module, &lines, &params).code_actions());
             code_action_inexhaustive_let_to_case(
                 module,

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

@@ -133,6 +133,7 @@ const GENERATE_VARIANT: &str = "Generate variant";
 const REMOVE_BLOCK: &str = "Remove block";
 const REMOVE_OPAQUE_FROM_PRIVATE_TYPE: &str = "Remove opaque from private type";
 const COLLAPSE_NESTED_CASE: &str = "Collapse nested case";
+const REMOVE_UNREACHABLE_BRANCHES: &str = "Remove unreachable branches";
 
 macro_rules! assert_code_action {
     ($title:expr, $code:literal, $range:expr $(,)?) => {
@@ -9757,3 +9758,41 @@ pub fn main() {
         find_position_of("subtract").to_selection()
     );
 }
+
+#[test]
+fn remove_unreachable_branches() {
+    assert_code_action!(
+        REMOVE_UNREACHABLE_BRANCHES,
+        "pub fn main(x) {
+  case x {
+    Ok(n) -> 1
+    Ok(_) -> 2
+    Error(_) -> todo
+    Ok(1) -> 3
+  }
+}
+",
+        find_position_of("Ok(1)").to_selection()
+    );
+}
+
+#[test]
+fn remove_unreachable_branches_does_not_pop_up_if_all_branches_are_reachable() {
+    assert_no_code_actions!(
+        REMOVE_UNREACHABLE_BRANCHES,
+        "pub fn main(x) {
+  case x {
+    Ok(n) -> 1
+    Error(_) -> todo
+  }
+
+  case x {
+    Ok(n) -> todo
+    Ok(_) -> todo
+    _ -> todo
+  }
+}
+",
+        find_position_of("Ok(n)").to_selection()
+    );
+}

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

@@ -0,0 +1,25 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+expression: "pub fn main(x) {\n  case x {\n    Ok(n) -> 1\n    Ok(_) -> 2\n    Error(_) -> todo\n    Ok(1) -> 3\n  }\n}\n"
+---
+----- BEFORE ACTION
+pub fn main(x) {
+  case x {
+    Ok(n) -> 1
+    Ok(_) -> 2
+    Error(_) -> todo
+    Ok(1) -> 3
+    ↑         
+  }
+}
+
+
+----- AFTER ACTION
+pub fn main(x) {
+  case x {
+    Ok(n) -> 1
+    
+    Error(_) -> todo
+    
+  }
+}