Move "Did you want a Bool" error to analysis step

Fixes #5052

Author: mxtthias

CHANGELOG.md

@@ -29,6 +29,11 @@
 
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- The lowercase bool pattern error is no longer a syntax error, but instead a
+  part of the analysis step. This allows the entire module to be analyzed, rather
+  than stopping at the syntax error.
+  ([mxtthias](https://github.com/mxtthias))
+
 ### Build tool
 
 - The help text displayed by `gleam dev --help`, `gleam test --help`, and

compiler-core/src/error.rs

@@ -4025,6 +4025,22 @@ with no constructors."
                             extra_labels: vec![],
                         }),
                     },
+
+                    TypeError::LowercaseBoolPattern { location } => Diagnostic {
+                        title: "Lowercase bool pattern".to_string(),
+                        text: "See: https://tour.gleam.run/basics/bools/".into(),
+                        hint: Some("In Gleam bool literals are `True` and `False`.".into()),
+                        level: Level::Error,
+                        location: Some(Location {
+                            label: Label {
+                                text: Some("This is not a bool".into()),
+                                span: *location,
+                            },
+                            path: path.clone(),
+                            src: src.clone(),
+                            extra_labels: vec![],
+                        }),
+                    },
                 })
                 .collect_vec(),
 

compiler-core/src/parse.rs

@@ -1278,22 +1278,14 @@ where
                         }
                     }
                 } else {
-                    match name.as_str() {
-                        "true" | "false" => {
-                            return parse_error(
-                                ParseErrorType::LowcaseBooleanPattern,
-                                SrcSpan { start, end },
-                            );
-                        }
-                        _ => Pattern::Variable {
-                            origin: VariableOrigin {
-                                syntax: VariableSyntax::Variable(name.clone()),
-                                declaration: position.to_declaration(),
-                            },
-                            location: SrcSpan { start, end },
-                            name,
-                            type_: (),
+                    Pattern::Variable {
+                        origin: VariableOrigin {
+                            syntax: VariableSyntax::Variable(name.clone()),
+                            declaration: position.to_declaration(),
                         },
+                        location: SrcSpan { start, end },
+                        name,
+                        type_: (),
                     }
                 }
             }

compiler-core/src/parse/error.rs

@@ -77,7 +77,6 @@ pub enum ParseErrorType {
     ListSpreadWithAnotherSpread {
         first_spread_location: SrcSpan,
     }, // trying to use multiple spreads: `[..xs, ..ys]`
-    LowcaseBooleanPattern, // most likely user meant True or False in patterns
     UnexpectedLabel, // argument labels were provided, but are not supported in this context
     UnexpectedEof,
     UnexpectedReservedWord, // reserved word used when a name was expected
@@ -420,13 +419,6 @@ utf16_codepoint, utf32_codepoint, signed, unsigned, big, little, native, size, u
                 extra_labels: vec![],
             },
 
-            ParseErrorType::LowcaseBooleanPattern => ParseErrorDetails {
-                text: "See: https://tour.gleam.run/basics/bools/".into(),
-                hint: Some("In Gleam boolean literals are `True` and `False`.".into()),
-                label_text: "Did you want a Bool instead of a variable?".into(),
-                extra_labels: vec![],
-            },
-
             ParseErrorType::UnexpectedLabel => ParseErrorDetails {
                 text: "Please remove the argument label.".into(),
                 hint: None,

compiler-core/src/parse/tests.rs

@@ -363,18 +363,6 @@ fn pointless_spread() {
     );
 }
 
-// https://github.com/gleam-lang/gleam/issues/1358
-#[test]
-fn lowcase_bool_in_pattern() {
-    assert_error!(
-        "case 42 > 42 { true -> 1; false -> 2; }",
-        ParseError {
-            error: ParseErrorType::LowcaseBooleanPattern,
-            location: SrcSpan { start: 15, end: 19 },
-        }
-    );
-}
-
 // https://github.com/gleam-lang/gleam/issues/1613
 #[test]
 fn anonymous_function_labeled_arguments() {

compiler-core/src/type_/error.rs

@@ -672,6 +672,10 @@ pub enum Error {
     ExternalTypeWithConstructors {
         location: SrcSpan,
     },
+
+    LowercaseBoolPattern {
+        location: SrcSpan,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -1310,7 +1314,8 @@ impl Error {
             | Error::NonUtf8StringAssignmentInBitArray { location }
             | Error::PrivateOpaqueType { location }
             | Error::SrcImportingDevDependency { location, .. }
-            | Error::ExternalTypeWithConstructors { location, .. } => location.start,
+            | Error::ExternalTypeWithConstructors { location, .. }
+            | Error::LowercaseBoolPattern { location } => location.start,
             Error::UnknownLabels { unknown, .. } => {
                 unknown.iter().map(|(_, s)| s.start).min().unwrap_or(0)
             }

compiler-core/src/type_/pattern.rs

@@ -608,16 +608,22 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                 location,
                 origin,
                 ..
-            } => {
-                self.insert_variable(&name, type_.clone(), location, origin.clone());
+            } => match name.as_str() {
+                "true" | "false" => {
+                    self.error(Error::LowercaseBoolPattern { location });
+                    Pattern::Invalid { location, type_ }
+                }
+                _ => {
+                    self.insert_variable(&name, type_.clone(), location, origin.clone());
 
-                Pattern::Variable {
-                    type_,
-                    name,
-                    location,
-                    origin,
+                    Pattern::Variable {
+                        type_,
+                        name,
+                        location,
+                        origin,
+                    }
                 }
-            }
+            },
 
             Pattern::BitArraySize(size) => {
                 let location = size.location();

compiler-core/src/type_/snapshots/gleam_core__type___tests__type_unification_does_not_allow_lowercase_bools_in_match_clause.snap

@@ -0,0 +1,32 @@
+---
+source: compiler-core/src/type_/tests.rs
+expression: "\npub fn main() {\n  case 42 > 42 {\n    true -> 1\n    false -> 2\n  }\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  case 42 > 42 {
+    true -> 1
+    false -> 2
+  }
+}
+
+
+----- ERROR
+error: Lowercase bool pattern
+  ┌─ /src/one/two.gleam:4:5
+  │
+4 │     true -> 1
+  │     ^^^^ This is not a bool
+
+See: https://tour.gleam.run/basics/bools/
+Hint: In Gleam bool literals are `True` and `False`.
+
+error: Lowercase bool pattern
+  ┌─ /src/one/two.gleam:5:5
+  │
+5 │     false -> 2
+  │     ^^^^^ This is not a bool
+
+See: https://tour.gleam.run/basics/bools/
+Hint: In Gleam bool literals are `True` and `False`.

compiler-core/src/type_/tests.rs

@@ -2134,6 +2134,21 @@ pub fn main() {
     );
 }
 
+// https://github.com/gleam-lang/gleam/issues/1358
+#[test]
+fn type_unification_does_not_allow_lowercase_bools_in_match_clause() {
+    assert_module_error!(
+        r#"
+pub fn main() {
+  case 42 > 42 {
+    true -> 1
+    false -> 2
+  }
+}
+"#
+    );
+}
+
 #[test]
 fn record_update_variant_inference_in_alternate_pattern_with_all_same_variants() {
     assert_module_infer!(