Improve expected Try type error message

Author: jaredramirez

src/check/Check.zig

@@ -4447,13 +4447,37 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, env: *Env, match: CIR.Exp
     // If so, we'll skip exhaustiveness checking since the types may be invalid
     var had_type_error = false;
 
+    // For matches desugared from `?` operator, verify the condition unifies with Try type FIRST.
+    // If it doesn't, report the specific error and skip pattern checking to avoid confusing errors.
+    var has_invalid_try = false;
+    if (match.is_try_suffix) {
+        // Get the actual Try type from builtins and instantiate it with fresh type vars
+        const try_type_var = ModuleEnv.varFrom(self.builtin_ctx.try_stmt);
+        const copied_try_var = if (self.builtin_ctx.builtin_module) |builtin_env|
+            try self.copyVar(try_type_var, builtin_env, Region.zero())
+        else
+            try_type_var;
+        const try_var = try self.instantiateVar(copied_try_var, env, .use_root_instantiated);
+
+        // Unify the condition with Try type
+        const try_result = try self.unify(try_var, cond_var, env);
+        if (!try_result.isOk()) {
+            has_invalid_try = true;
+            self.setDetailIfTypeMismatch(try_result, problem.TypeMismatchDetail{ .invalid_try_operator = .{
+                .expr = match.cond,
+            } });
+        }
+    }
+
     // Manually check the 1st branch
     // The type of the branch's body becomes the var other branch bodies must unify
     // against.
     const first_branch_idx = branch_idxs[0];
     const first_branch = self.cir.store.getMatchBranch(first_branch_idx);
     const first_branch_ptrn_idxs = self.cir.store.sliceMatchBranchPatterns(first_branch.patterns);
 
+    // Skip pattern checking if we already know the condition isn't a Try type
+    // This prevents confusing cascading errors about pattern incompatibility
     for (first_branch_ptrn_idxs) |branch_ptrn_idx| {
         const branch_ptrn = self.cir.store.getMatchBranchPattern(branch_ptrn_idx);
         try self.checkPattern(branch_ptrn.pattern, env);
@@ -4474,7 +4498,7 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, env: *Env, match: CIR.Exp
     for (branch_idxs[1..], 1..) |branch_idx, branch_cur_index| {
         const branch = self.cir.store.getMatchBranch(branch_idx);
 
-        // First, check the patterns of this branch
+        // First, check the patterns of this branch (skip if invalid try to avoid confusing errors)
         const branch_ptrn_idxs = self.cir.store.sliceMatchBranchPatterns(branch.patterns);
         for (branch_ptrn_idxs, 0..) |branch_ptrn_idx, cur_ptrn_index| {
             // Check the pattern's sub types
@@ -4509,7 +4533,7 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, env: *Env, match: CIR.Exp
             for (branch_idxs[branch_cur_index + 1 ..], branch_cur_index + 1..) |other_branch_idx, other_branch_cur_index| {
                 const other_branch = self.cir.store.getMatchBranch(other_branch_idx);
 
-                // Still check the other patterns
+                // Still check the other patterns (skip if invalid try to avoid confusing errors)
                 const other_branch_ptrn_idxs = self.cir.store.sliceMatchBranchPatterns(other_branch.patterns);
                 for (other_branch_ptrn_idxs, 0..) |other_branch_ptrn_idx, other_cur_ptrn_index| {
                     // Check the pattern's sub types
@@ -4538,29 +4562,6 @@ fn checkMatchExpr(self: *Self, expr_idx: CIR.Expr.Idx, env: *Env, match: CIR.Exp
         }
     }
 
-    // For matches desugared from `?` operator, verify the condition unifies with Try type.
-    // If it doesn't, report an error. Skip exhaustiveness checking for invalid try since
-    // the desugared match only handles Ok/Err branches and would report confusing errors.
-    var has_invalid_try = false;
-    if (match.is_try_suffix) {
-        // Get the actual Try type from builtins and instantiate it with fresh type vars
-        const try_type_var = ModuleEnv.varFrom(self.builtin_ctx.try_stmt);
-        const copied_try_var = if (self.builtin_ctx.builtin_module) |builtin_env|
-            try self.copyVar(try_type_var, builtin_env, Region.zero())
-        else
-            try_type_var;
-        const try_var = try self.instantiateVar(copied_try_var, env, .use_root_instantiated);
-
-        // Unify the condition with Try type
-        const try_result = try self.unify(try_var, cond_var, env);
-        if (!try_result.isOk()) {
-            has_invalid_try = true;
-            self.setDetailIfTypeMismatch(try_result, problem.TypeMismatchDetail{ .invalid_try_operator = .{
-                .expr = match.cond,
-            } });
-        }
-    }
-
     // Unify the root expr with the match value
     _ = try self.unify(ModuleEnv.varFrom(expr_idx), val_var, env);
 

test/snapshots/eval/issue8738_question_on_non_try.md

@@ -20,26 +20,23 @@ do_something = || {
 result = do_something()
 ~~~
 # EXPECTED
-INCOMPATIBLE MATCH PATTERNS - issue8738_question_on_non_try.md:9:7:9:7
+EXPECTED TRY TYPE - issue8738_question_on_non_try.md:9:7:9:7
 # PROBLEMS
-**INCOMPATIBLE MATCH PATTERNS**
-The first pattern in this `match` is incompatible:
+**EXPECTED TRY TYPE**
+The `?` operator expects a _Try_ type (a tag union containing ONLY _Ok_ and _Err_ tags),
+but I found:
 **issue8738_question_on_non_try.md:9:7:**
 ```roc
 	_x = ok_or(Err(""), Exit(5))?
 ```
-      ^^^^^^^^^^^^^^^^^^^^^^^^
+      ^^^^^^^^^^^^^^^^^^^^^^^
 
-The first pattern has the type:
+This expression has type:
 
-    Try(ok, err)
+_[Exit(a), .._others]
+  where [a.from_numeral : Numeral -> Try(a, [InvalidNumeral(Str)])]_
 
-But the expression between the `match` parenthesis has the type:
-
-    [Exit(a), .._others]
-      where [a.from_numeral : Numeral -> Try(a, [InvalidNumeral(Str)])]
-
-These two types can never match!
+Tip: Maybe wrap a value using _Ok(value)_ or _Err(value)_.
 
 # TOKENS
 ~~~zig

test/snapshots/try_undefined_tag.md

@@ -9,7 +9,7 @@ A?
 ~~~
 # EXPECTED
 TRY OPERATOR OUTSIDE FUNCTION - try_undefined_tag.md:1:1:1:3
-INCOMPATIBLE MATCH PATTERNS - try_undefined_tag.md:1:1:1:1
+EXPECTED TRY TYPE - try_undefined_tag.md:1:1:1:1
 # PROBLEMS
 **TRY OPERATOR OUTSIDE FUNCTION**
 The `?` operator can only be used inside function bodies because it can cause an early return.
@@ -21,23 +21,20 @@ A?
 ^^
 
 
-**INCOMPATIBLE MATCH PATTERNS**
-The first pattern in this `match` is incompatible:
+**EXPECTED TRY TYPE**
+The `?` operator expects a _Try_ type (a tag union containing ONLY _Ok_ and _Err_ tags),
+but I found:
 **try_undefined_tag.md:1:1:**
 ```roc
 A?
 ```
-^^
-
-The first pattern has the type:
-
-    Try(ok, err)
+^
 
-But the expression between the `match` parenthesis has the type:
+This expression has type:
 
-    [A, .._others]
+_[A, .._others]_
 
-These two types can never match!
+Tip: Maybe wrap a value using _Ok(value)_ or _Err(value)_.
 
 # TOKENS
 ~~~zig