✨ Improve error for wrong number of subjects

Author: fruno-bulax

compiler-core/src/type_/expression.rs

@@ -2339,7 +2339,7 @@ impl<'a, 'b> ExprTyper<'a, 'b> {
             PatternPosition::CaseClause,
         );
 
-        let typed_pattern = pattern_typer.infer_multi_pattern(pattern, subjects, location);
+        let typed_pattern = pattern_typer.infer_multi_pattern(pattern, subjects);
 
         // Each case clause has one or more patterns that may match the
         // subject in order for the clause to be selected, so we must type

compiler-core/src/type_/pattern.rs

@@ -266,7 +266,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         location: &SrcSpan,
     ) -> Vec<TypedPattern> {
         self.mode = PatternMode::Alternative(vec![]);
-        let typed_multi = self.infer_multi_pattern(multi_pattern, subjects, location);
+        let typed_multi = self.infer_multi_pattern(multi_pattern, subjects);
 
         if self.error_encountered {
             return typed_multi;
@@ -300,12 +300,18 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         &mut self,
         multi_pattern: UntypedMultiPattern,
         subjects: &[TypedExpr],
-        location: &SrcSpan,
     ) -> Vec<TypedPattern> {
         // If there are N subjects the multi-pattern is expected to be N patterns
         if subjects.len() != multi_pattern.len() {
+            let first = multi_pattern
+                .first()
+                .expect("multi-pattern to contain at least one pattern");
+            let last = multi_pattern
+                .last()
+                .expect("multi-pattern to contain at least one pattern");
+
             self.error(Error::IncorrectNumClausePatterns {
-                location: *location,
+                location: first.location().merge(&last.location()),
                 expected: subjects.len(),
                 given: multi_pattern.len(),
             });

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

@@ -385,6 +385,11 @@ fn wrong_number_of_subjects() {
     assert_error!("case 1 { _, _ -> 1 }");
 }
 
+#[test]
+fn wrong_number_of_subjects_alternative_patterns() {
+    assert_error!("case 1 { _, _ | _ | _, _, _ -> 1 }");
+}
+
 #[test]
 fn recursive_var() {
     assert_error!("let id = fn(x) { x(x) } 1");

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

@@ -10,7 +10,7 @@ error: Incorrect number of patterns
   ┌─ /src/one/two.gleam:1:10
   │
 1 │ case 1 { _, _ -> 1 }
-  │          ^^^^^^^^^ Expected 1 patterns, got 2
+  │          ^^^^ Expected 1 patterns, got 2
 
 This case expression has 1 subjects, but this pattern matches 2.
 Each clause must have a pattern for every subject value.

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

@@ -0,0 +1,25 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "case 1 { _, _ | _ | _, _, _ -> 1 }"
+---
+----- SOURCE CODE
+case 1 { _, _ | _ | _, _, _ -> 1 }
+
+----- ERROR
+error: Incorrect number of patterns
+  ┌─ /src/one/two.gleam:1:10
+  │
+1 │ case 1 { _, _ | _ | _, _, _ -> 1 }
+  │          ^^^^ Expected 1 patterns, got 2
+
+This case expression has 1 subjects, but this pattern matches 2.
+Each clause must have a pattern for every subject value.
+
+error: Incorrect number of patterns
+  ┌─ /src/one/two.gleam:1:21
+  │
+1 │ case 1 { _, _ | _ | _, _, _ -> 1 }
+  │                     ^^^^^^^ Expected 1 patterns, got 3
+
+This case expression has 1 subjects, but this pattern matches 3.
+Each clause must have a pattern for every subject value.