added warning on empty clause in the compiler

Signed-off-by: Courtcircuits <[email protected]>

Author: Courtcircuits

CHANGELOG.md

@@ -408,3 +408,6 @@
 - Fixed a bug where the compiler would suggest to use a discarded value defined
   in a different function.
   ([Giacomo Cavalieri](https://github.com/giacomocavalieri))
+
+- Fixed a bug where the compiler allowed to write a guard with an empty clause.
+  ([Tristan-Mihai Radulescu][https://github.com/Courtcircuits])

compiler-core/src/parse.rs

@@ -1622,11 +1622,19 @@ where
     //   if a < b
     //   if a < b || b < c
     fn parse_case_clause_guard(&mut self) -> Result<Option<UntypedClauseGuard>, ParseError> {
-        if self.maybe_one(&Token::If).is_some() {
-            self.parse_clause_guard_inner()
-        } else {
-            Ok(None)
+        let Some((start, end)) = self.maybe_one(&Token::If) else {
+            return Ok(None);
+        };
+        let guard_clause_result = self.parse_clause_guard_inner();
+        // if inner clause is none, a warning should be thrown to prevent that this behaviour
+        // is deprecated
+        if let Ok(None) = guard_clause_result {
+            self.warnings
+                .push(DeprecatedSyntaxWarning::DeprecatedEmptyGuardClause {
+                    location: SrcSpan { start, end },
+                });
         }
+        guard_clause_result
     }
 
     fn parse_clause_guard_inner(&mut self) -> Result<Option<UntypedClauseGuard>, ParseError> {

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

@@ -0,0 +1,26 @@
+---
+source: compiler-core/src/type_/tests/warnings.rs
+expression: "\npub fn main() {\n    let wibble = 10\n    case wibble {\n        10 if -> True\n        _ -> False\n    }\n\n}"
+---
+----- SOURCE CODE
+
+pub fn main() {
+    let wibble = 10
+    case wibble {
+        10 if -> True
+        _ -> False
+    }
+
+}
+
+----- WARNING
+warning: Deprecated empty guard clause syntax
+  ┌─ test/path:5:12
+  │
+5 │         10 if -> True
+  │            ^^ This should be followed by a guard or removed!!
+
+
+Empty clause within a guard is deprecated.
+To keep its behaviour, either remove the guard or fill the clause with
+`True` instead.

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

@@ -4314,3 +4314,18 @@ pub fn wibble() { x }
 "
     );
 }
+
+#[test]
+fn empty_guard_clause() {
+    assert_warning!(
+        "
+pub fn main() {
+    let wibble = 10
+    case wibble {
+        10 if -> True
+        _ -> False
+    }
+
+}"
+    );
+}

compiler-core/src/warning.rs

@@ -242,6 +242,17 @@ pub enum DeprecatedSyntaxWarning {
         location: SrcSpan,
     },
 
+    /// If a guard has an empty clause :
+    /// ```gleam
+    /// case wibble {
+    ///     big if -> True
+    ///         ^^ this should be followed by a guard or removed!!
+    /// }
+    /// ```
+    DeprecatedEmptyGuardClause {
+        location: SrcSpan,
+    },
+
     DeprecatedTargetShorthand {
         target: Target,
         location: SrcSpan,
@@ -355,7 +366,29 @@ To match on all possible lists, use the `_` catch-all pattern instead.",
                     extra_labels: vec![],
                 }),
             },
-
+            Warning::DeprecatedSyntax {
+                path,
+                src,
+                warning: DeprecatedSyntaxWarning::DeprecatedEmptyGuardClause { location },
+            } => Diagnostic {
+                title: "Deprecated empty guard clause syntax".into(),
+                text: wrap(
+                    "Empty clause within a guard is deprecated.
+To keep its behaviour, either remove the guard or fill the clause with `True` instead.",
+                ),
+                hint: None,
+                level: diagnostic::Level::Warning,
+                location: Some(Location {
+                    label: diagnostic::Label {
+                        text: Some("This should be followed by a guard or removed!!
+".into()),
+                        span: *location,
+                    },
+                    path: path.clone(),
+                    src: src.clone(),
+                    extra_labels: vec![],
+                }),
+            },
             Warning::DeprecatedSyntax {
                 path,
                 src,

docs/v2.md

@@ -40,5 +40,5 @@ compatibility.
 It doesn't make sense to have an `if` guard followed by no condition, but the
 compiler allows this: `case wibble { big if -> True }`
 
-- [ ] Emits warning when used.
+- [x] Emits warning when used.
 - [x] Formatter rewrites it to desired syntax.