They are called clauses, not branches

Author: lpil

CHANGELOG.md

@@ -58,7 +58,7 @@
 
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
-- The compiler now raises a warning for unreachable branches that are matching
+- The compiler now raises a warning for unreachable clauses that are matching
   on bit array segments that could never match. Consider this example:
 
   ```gleam
@@ -71,7 +71,7 @@
   }
   ```
 
-  There's a subtle bug here. The second branch can never match since it's
+  There's a subtle bug here. The second clause can never match since it's
   impossible for the first byte of the bit array to have the value `404`.
   The new error explains this nicely:
 
@@ -383,23 +383,23 @@
 ### Language server
 
 - The language server now offers a code action to remove all the unreachable
-  branches in a case expression. For example:
+  clauses in a case expression. For example:
 
   ```gleam
   pub fn main() {
     case find_user() {
       Ok(user) -> todo
       Ok(Admin) -> todo
-  //  ^^^^^^^^^ This branch is unreachable
+  //  ^^^^^^^^^ This clause is unreachable
       Ok(User) -> todo
-  //  ^^^^^^^^ This branch is unreachable
+  //  ^^^^^^^^ This clause is unreachable
       Error(_) -> todo
     }
   }
   ```
 
-  Hovering over one of the unreachable branches and triggering the code action
-  would remove all the unreachable branches:
+  Hovering over one of the unreachable clauses and triggering the code action
+  would remove all the unreachable clauses:
 
   ```gleam
   pub fn main() {

compiler-core/src/language_server/code_action.rs

@@ -3706,14 +3706,14 @@ impl<'a> GenerateDynamicDecoder<'a> {
             eco_format!("use variant <- {module}.field(\"type\", {module}.string)")
         };
 
-        let mut branches = Vec::with_capacity(constructors_size);
+        let mut clauses = Vec::with_capacity(constructors_size);
         for constructor in iter::once(first).chain(rest) {
             let body = self.constructor_decoder(mode, custom_type, constructor, 4)?;
             let name = to_snake_case(&constructor.name);
-            branches.push(eco_format!(r#"    "{name}" -> {body}"#));
+            clauses.push(eco_format!(r#"    "{name}" -> {body}"#));
         }
 
-        let cases = branches.join("\n");
+        let cases = clauses.join("\n");
         let type_name = &custom_type.name;
         Some(eco_format!(
             r#"{{
@@ -4116,7 +4116,7 @@ impl<'a> GenerateJsonEncoder<'a> {
         // Otherwise we generate an encoder for a type with multiple constructors:
         // it will need to pattern match on the various constructors and encode each
         // one separately.
-        let mut branches = Vec::with_capacity(constructors_size);
+        let mut clauses = Vec::with_capacity(constructors_size);
         for constructor in iter::once(first).chain(rest) {
             let RecordConstructor { name, .. } = constructor;
             let encoder =
@@ -4135,13 +4135,13 @@ impl<'a> GenerateJsonEncoder<'a> {
                         .join(":, ")
                 )
             };
-            branches.push(eco_format!("    {name}{unpacking} -> {encoder}"));
+            clauses.push(eco_format!("    {name}{unpacking} -> {encoder}"));
         }
 
-        let branches = branches.join("\n");
+        let clauses = clauses.join("\n");
         Some(eco_format!(
             "case {record_name} {{
-{branches}
+{clauses}
   }}",
         ))
     }
@@ -4720,7 +4720,7 @@ impl<'a, IO> PatternMatchOnValue<'a, IO> {
             Type::Var { type_ } => self.type_var_to_destructure_patterns(&type_.borrow()),
 
             // We special case lists, they don't have "regular" constructors
-            // like other types. Instead we always add the two branches covering
+            // like other types. Instead we always add the two clauses covering
             // the empty and non empty list.
             Type::Named { .. } if type_.is_list() => {
                 Some(vec1!["[]".into(), "[first, ..rest]".into()])
@@ -8230,53 +8230,53 @@ fn single_expression(expression: &TypedExpr) -> Option<&TypedExpr> {
     }
 }
 
-/// Code action to remove `opaque` from a private type.
+/// Code action to remove unreachable clauses from a case expression.
 ///
-pub struct RemoveUnreachableBranches<'a> {
+pub struct RemoveUnreachableCaseClauses<'a> {
     module: &'a Module,
     params: &'a CodeActionParams,
     edits: TextEdits<'a>,
-    /// The source location of the patterns of all the unreachable branches in
+    /// The source location of the patterns of all the unreachable clauses in
     /// the current module.
     ///
-    unreachable_branches: HashSet<SrcSpan>,
-    branches_to_delete: Vec<SrcSpan>,
+    unreachable_clauses: HashSet<SrcSpan>,
+    clauses_to_delete: Vec<SrcSpan>,
 }
 
-impl<'a> RemoveUnreachableBranches<'a> {
+impl<'a> RemoveUnreachableCaseClauses<'a> {
     pub fn new(
         module: &'a Module,
         line_numbers: &'a LineNumbers,
         params: &'a CodeActionParams,
     ) -> Self {
-        let unreachable_branches = (module.ast.type_info.warnings.iter())
+        let unreachable_clauses = (module.ast.type_info.warnings.iter())
             .filter_map(|warning| match warning {
                 type_::Warning::UnreachableCasePattern { location, .. } => Some(*location),
                 _ => None,
             })
             .collect();
 
         Self {
-            unreachable_branches,
+            unreachable_clauses,
             module,
             params,
             edits: TextEdits::new(line_numbers),
-            branches_to_delete: vec![],
+            clauses_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() {
+        if self.clauses_to_delete.is_empty() {
             return vec![];
         }
 
-        for branch in self.branches_to_delete {
+        for branch in self.clauses_to_delete {
             self.edits.delete(branch);
         }
 
         let mut action = Vec::with_capacity(1);
-        CodeActionBuilder::new("Remove unreachable branches")
+        CodeActionBuilder::new("Remove unreachable clauses")
             .kind(CodeActionKind::QUICKFIX)
             .changes(self.params.text_document.uri.clone(), self.edits.edits)
             .preferred(true)
@@ -8285,7 +8285,7 @@ impl<'a> RemoveUnreachableBranches<'a> {
     }
 }
 
-impl<'ast> ast::visit::Visit<'ast> for RemoveUnreachableBranches<'ast> {
+impl<'ast> ast::visit::Visit<'ast> for RemoveUnreachableCaseClauses<'ast> {
     fn visit_typed_expr_case(
         &mut self,
         location: &'ast SrcSpan,
@@ -8302,18 +8302,18 @@ impl<'ast> ast::visit::Visit<'ast> for RemoveUnreachableBranches<'ast> {
             within(self.params.range, pattern_range)
         });
         if is_hovering_clause {
-            self.branches_to_delete = clauses
+            self.clauses_to_delete = clauses
                 .iter()
                 .filter(|clause| {
-                    self.unreachable_branches
+                    self.unreachable_clauses
                         .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
+        // If we're not hovering any of the 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

@@ -14,7 +14,7 @@ use crate::{
     language_server::{
         code_action::{
             AddOmittedLabels, CollapseNestedCase, ExtractFunction, RemoveBlock,
-            RemovePrivateOpaque, RemoveUnreachableBranches,
+            RemovePrivateOpaque, RemoveUnreachableCaseClauses,
         },
         compiler::LspProjectCompiler,
         files::FileSystemProxy,
@@ -408,7 +408,8 @@ 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(RemoveUnreachableCaseClauses::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,7 +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";
+const REMOVE_UNREACHABLE_CLAUSES: &str = "Remove unreachable clauses";
 const ADD_OMITTED_LABELS: &str = "Add omitted labels";
 const EXTRACT_FUNCTION: &str = "Extract function";
 
@@ -10003,9 +10003,9 @@ pub fn main() {
 }
 
 #[test]
-fn remove_unreachable_branches() {
+fn remove_unreachable_clauses() {
     assert_code_action!(
-        REMOVE_UNREACHABLE_BRANCHES,
+        REMOVE_UNREACHABLE_CLAUSES,
         "pub fn main(x) {
   case x {
     Ok(n) -> 1
@@ -10022,7 +10022,7 @@ fn remove_unreachable_branches() {
 #[test]
 fn remove_unreachable_branches_does_not_pop_up_if_all_branches_are_reachable() {
     assert_no_code_actions!(
-        REMOVE_UNREACHABLE_BRANCHES,
+        REMOVE_UNREACHABLE_CLAUSES,
         "pub fn main(x) {
   case x {
     Ok(n) -> 1

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

@@ -0,0 +1,27 @@
+---
+source: compiler-core/src/language_server/tests/action.rs
+assertion_line: 10007
+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"
+snapshot_kind: text
+---
+----- 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
+    
+  }
+}