Deprecate _ as x patterns

CHANGELOG.md

@@ -336,6 +336,9 @@
 
   ([Louis Pilfold](https://github.com/lpil))
 
+- A warning is now emitted when the now deprecated `_ as x` pattern is used.
+  ([eutampieri](https://github.com/eutampieri))
+
 - The compiler now allows using bit array options to specify endianness when
   constructing or pattern matching on UTF codepoints in bit arrays.
   ([Surya Rose](https://github.com/GearsDatapacks))
@@ -603,6 +606,9 @@
 
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
 
+- Implememted rewrite of `_ as x` patterns to `x`.
+  ([eutampieri](https://github.com/eutampieri))
+
 ### Bug fixes
 
 - Fixed a bug where the language server would not show type-related code actions

compiler-core/src/format.rs

@@ -2250,7 +2250,11 @@ impl<'comments> Formatter<'comments> {
             Pattern::BitArraySize(size) => self.bit_array_size(size),
 
             Pattern::Assign { name, pattern, .. } => {
-                self.pattern(pattern).append(" as ").append(name.as_str())
+                if pattern.is_discard() {
+                    name.to_doc()
+                } else {
+                    self.pattern(pattern).append(" as ").append(name.as_str())
+                }
             }
 
             Pattern::Discard { name, .. } => name.to_doc(),

compiler-core/src/format/tests.rs

@@ -6685,3 +6685,24 @@ fn assert_as_with_comment_before_the_as() {
 "#
     );
 }
+
+// https://github.com/gleam-lang/gleam/issues/4664
+#[test]
+fn pattern_unused_discard() {
+    assert_format_rewrite!(
+        r#"pub fn main() {
+  let a = 10
+  let _ = case a {
+    _ as b -> b
+  }
+}
+"#,
+        r#"pub fn main() {
+  let a = 10
+  let _ = case a {
+    b -> b
+  }
+}
+"#
+    );
+}

compiler-core/src/type_/error.rs

@@ -870,6 +870,11 @@ pub enum Warning {
         reason: UnreachablePatternReason,
     },
 
+    UnusedDiscardPattern {
+        location: SrcSpan,
+        name: EcoString,
+    },
+
     /// This happens when someone tries to write a case expression where one of
     /// the subjects is a literal tuple, list or bit array for example:
     ///
@@ -1272,6 +1277,7 @@ impl Warning {
             | Warning::AssertLiteralBool { location, .. }
             | Warning::BitArraySegmentTruncatedValue { location, .. }
             | Warning::TopLevelDefinitionShadowsImport { location, .. }
+            | Warning::UnusedDiscardPattern { location, .. }
             | Warning::ModuleImportedTwice {
                 second: location, ..
             }

compiler-core/src/type_/pattern.rs

@@ -694,6 +694,13 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                 location,
             } => {
                 let pattern = self.unify(*pattern, type_, subject_variable);
+
+                if pattern.is_discard() {
+                    self.problems.warning(Warning::UnusedDiscardPattern {
+                        location,
+                        name: name.clone(),
+                    });
+                }
                 self.insert_variable(
                     &name,
                     pattern.type_().clone(),

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__warnings__unused_discard_pattern.snap

@@ -0,0 +1,23 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+assertion_line: 4195
+expression: "pub fn main() {\n  let a = 10\n  let _ = case a {\n    _ as b -> b\n  }\n}\n"
+snapshot_kind: text
+---
+----- SOURCE CODE
+pub fn main() {
+  let a = 10
+  let _ = case a {
+    _ as b -> b
+  }
+}
+
+
+----- WARNING
+warning: Unused discard pattern
+  ┌─ /src/warning/wrn.gleam:4:5
+  │
+4 │     _ as b -> b
+  │     ^^^^^^
+
+`_ as b` can be written more concisely as `b`

compiler-core/src/type_/tests/warnings.rs

@@ -4189,3 +4189,16 @@ pub fn main() -> Bool {
 "
     );
 }
+
+#[test]
+fn unused_discard_pattern() {
+    assert_warning!(
+        "pub fn main() {
+  let a = 10
+  let _ = case a {
+    _ as b -> b
+  }
+}
+"
+    );
+}

compiler-core/src/warning.rs

@@ -1304,6 +1304,25 @@ can already tell whether it will be `True` or `False`.",
                     }),
                 },
 
+                type_::Warning::UnusedDiscardPattern { location, name } => Diagnostic {
+                    title: "Unused discard pattern".into(),
+                    text: format!("`_ as {name}` can be written more concisely as `{name}`"),
+                    level: diagnostic::Level::Warning,
+                    location: Some(Location {
+                        src: src.clone(),
+                        path: path.to_path_buf(),
+                        label: diagnostic::Label {
+                            text: None,
+                            span: SrcSpan {
+                                start: location.start - "_ as ".len() as u32,
+                                end: location.end,
+                            },
+                        },
+                        extra_labels: vec![],
+                    }),
+                    hint: None,
+                },
+
                 type_::Warning::TopLevelDefinitionShadowsImport { location, name } => {
                     let text = format!(
                         "Definition of {name} shadows an imported value.

docs/v2.md

@@ -12,8 +12,8 @@ Due to a bug in the parser we accept `[1, ..]` as a valid list value.
 This pattern doesn't make sense as one could write `a` instead. We don't want
 two ways of doing the same thing.
 
-- [ ] Emits warning when used.
-- [ ] Formatter rewrites it to desired syntax.
+- [X] Emits warning when used.
+- [X] Formatter rewrites it to desired syntax.
 
 ## Shadowing imported values