properly deal with patterns using labels and the label shorthand syntax

Author: giacomocavalieri

compiler-core/src/ast.rs

@@ -1536,9 +1536,9 @@ where
     /// If the call arg is defined using a label shorthand, this will return the
     /// label name.
     ///
-    fn label_shorthand_name(&self) -> Option<EcoString> {
+    pub fn label_shorthand_name(&self) -> Option<&EcoString> {
         if !self.is_implicit() && self.location == self.value.location() {
-            self.label.clone()
+            self.label.as_ref()
         } else {
             None
         }
@@ -2792,7 +2792,7 @@ impl TypedPattern {
                 for argument in arguments {
                     if let Some(name) = argument.label_shorthand_name() {
                         variables.push(BoundVariable::ShorthandLabel {
-                            name,
+                            name: name.clone(),
                             location: argument.location,
                         })
                     } else {

compiler-core/src/language_server/code_action.rs

@@ -4567,6 +4567,15 @@ where
             .iter()
             .map(|pattern| {
                 let mut clause_code = clause_code.to_string();
+                // If we're replacing a variable that's using the shorthand
+                // syntax we want to add a space to separate it from the
+                // preceding `:`.
+                let pattern = if variable_start == variable_end {
+                    &eco_format!(" {pattern}")
+                } else {
+                    pattern
+                };
+
                 clause_code.replace_range(variable_start..variable_end, pattern);
                 clause_code
             })
@@ -4886,6 +4895,24 @@ where
         }
     }
 
+    fn visit_typed_pattern_call_arg(&mut self, arg: &'ast CallArg<TypedPattern>) {
+        if let Some(name) = arg.label_shorthand_name()
+            && within(
+                self.params.range,
+                self.edits.src_span_to_lsp_range(arg.location),
+            )
+        {
+            let location = SrcSpan {
+                start: arg.location.end,
+                end: arg.location.end,
+            };
+            self.pattern_variable_under_cursor = Some((name, location, arg.value.type_()));
+            return;
+        }
+
+        ast::visit::visit_typed_pattern_call_arg(self, arg);
+    }
+
     fn visit_typed_pattern_string_prefix(
         &mut self,
         _location: &'ast SrcSpan,

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

@@ -6991,6 +6991,54 @@ fn maybe_wibble() { Ok(Wobble) }
     );
 }
 
+#[test]
+fn pattern_match_on_clause_variable_with_label() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  case wibble() {
+    Wobble(wibble: something) -> 1
+    _ -> 2
+  }
+}
+
+type Wibble {
+  Wobble(wibble: Wibble)
+  Woo
+}
+
+fn new() { Wobble }
+
+",
+        find_position_of("something").to_selection()
+    );
+}
+
+#[test]
+fn pattern_match_on_clause_variable_with_label_shorthand() {
+    assert_code_action!(
+        PATTERN_MATCH_ON_VARIABLE,
+        "
+pub fn main() {
+  case new() {
+    Wobble(wibble:) -> 1
+    _ -> 2
+  }
+}
+
+type Wibble {
+  Wobble(wibble: Wibble)
+  Woo
+}
+
+fn new() { Wobble }
+
+",
+        find_position_of("wibble").to_selection()
+    );
+}
+
 #[test]
 fn pattern_match_on_clause_variable_nested_pattern() {
     assert_code_action!(

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

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

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

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