better error spans

Author: roryc89

src/typechecker/infer.rs

@@ -917,7 +917,7 @@ impl InferCtx {
                     .collect();
 
                 // Unify the argument with the instantiated param
-                self.state.unify(span, &arg_ty, &instantiated_param)?;
+                self.state.unify(arg.span(), &arg_ty, &instantiated_param)?;
 
                 // Post-check 1: verify no forall var leaked into ambient vars' solutions.
                 // Catches escapes like `\x -> foo x` where x's type gets constrained
@@ -988,15 +988,15 @@ impl InferCtx {
 
         let result_ty = Type::Unif(self.state.fresh_var());
         let expected_func_ty = Type::fun(arg_ty, result_ty.clone());
-        self.state.unify(span, &func_ty, &expected_func_ty)?;
+        self.state.unify(arg.span(), &func_ty, &expected_func_ty)?;
 
         Ok(result_ty)
     }
 
     fn infer_if(
         &mut self,
         env: &Env,
-        span: crate::span::Span,
+        _span: crate::span::Span,
         cond: &Expr,
         then_expr: &Expr,
         else_expr: &Expr,
@@ -1009,7 +1009,7 @@ impl InferCtx {
 
         let then_ty = self.infer(env, then_expr)?;
         let else_ty = self.infer(env, else_expr)?;
-        self.state.unify(span, &then_ty, &else_ty)?;
+        self.state.unify(else_expr.span(), &then_ty, &else_ty)?;
 
         if is_underscore {
             Ok(Type::fun(Type::boolean(), then_ty))
@@ -1725,7 +1725,11 @@ impl InferCtx {
 
             // Infer the body and unify with result type
             let body_ty = self.infer_guarded(&alt_env, &alt.result)?;
-            self.state.unify(span, &result_ty, &body_ty)?;
+            let body_span = match &alt.result {
+                GuardedExpr::Unconditional(e) => e.span(),
+                GuardedExpr::Guarded(_) => alt.span,
+            };
+            self.state.unify(body_span, &result_ty, &body_ty)?;
         }
 
         // Exhaustiveness check: for each scrutinee, verify all constructors are covered
@@ -1782,14 +1786,14 @@ impl InferCtx {
     fn infer_array(
         &mut self,
         env: &Env,
-        span: crate::span::Span,
+        _span: crate::span::Span,
         elements: &[Expr],
     ) -> Result<Type, TypeError> {
         let elem_ty = Type::Unif(self.state.fresh_var());
 
         for elem in elements {
             let t = self.infer(env, elem)?;
-            self.state.unify(span, &elem_ty, &t)?;
+            self.state.unify(elem.span(), &elem_ty, &t)?;
         }
 
         Ok(Type::array(elem_ty))
@@ -2193,7 +2197,7 @@ impl InferCtx {
 
                 // Apply: func expr (\_ -> rest)
                 let after_first = Type::Unif(self.state.fresh_var());
-                self.state.unify(span, &func_ty, &Type::fun(expr_ty, after_first.clone()))?;
+                self.state.unify(expr.span(), &func_ty, &Type::fun(expr_ty, after_first.clone()))?;
                 let discard_arg = Type::Unif(self.state.fresh_var());
                 let cont_ty = Type::fun(discard_arg, rest_ty);
                 let result = Type::Unif(self.state.fresh_var());
@@ -2223,7 +2227,7 @@ impl InferCtx {
 
                 // Apply: bind expr (\binder -> rest)
                 let after_first = Type::Unif(self.state.fresh_var());
-                self.state.unify(span, &func_ty, &Type::fun(expr_ty, after_first.clone()))?;
+                self.state.unify(expr.span(), &func_ty, &Type::fun(expr_ty, after_first.clone()))?;
                 let cont_ty = Type::fun(binder_ty, rest_ty);
                 let result = Type::Unif(self.state.fresh_var());
                 self.state.unify(span, &after_first, &Type::fun(cont_ty, result.clone()))?;

tests/snapshots.rs

@@ -100,7 +100,7 @@ fn snap_expr_negate() {
 fn snap_expr_error_branch_mismatch() {
     insta::assert_snapshot!(
         format_expr_type(r#"if true then 1 else "x""#),
-        @"ERROR: Could not match type Int with type String at 0:23"
+        @"ERROR: Could not match type Int with type String at 20:23"
     );
 }
 

tests/typechecker_comprehensive.rs

@@ -142,6 +142,20 @@ fn assert_module_not_implemented(source: &str) {
     );
 }
 
+/// Assert that a type error's span covers exactly the expected source text.
+fn assert_error_span_text(source: &str, error_code: &str, expected_text: &str) {
+    let (_, errors) = check_module_types(source);
+    let err = errors.iter().find(|e| e.code() == error_code)
+        .unwrap_or_else(|| panic!("expected {} error, got errors: {:?}", error_code, errors.iter().map(|e| format!("{} ({})", e.code(), e)).collect::<Vec<_>>()));
+    let span = err.span();
+    assert!(span.start <= span.end && span.end <= source.len(),
+        "error span for {} is invalid: start={}, end={}, source len={}",
+        error_code, span.start, span.end, source.len());
+    let actual = &source[span.start..span.end];
+    assert_eq!(actual, expected_text,
+        "error span for {} should cover '{}' but covers '{}'", error_code, expected_text, actual);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // 1. LITERALS
 // ═══════════════════════════════════════════════════════════════════════════
@@ -7945,3 +7959,62 @@ x = Wrap 42";
         Type::app(Type::con("A", "Wrapper"), Type::int())
     );
 }
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ERROR SPAN PRECISION TESTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+#[test]
+fn error_span_if_else_branch_mismatch() {
+    assert_error_span_text(
+        r#"module Test where
+x = if true then 1 else "a""#,
+        "UnificationError",
+        "\"a\""
+    );
+}
+
+#[test]
+fn error_span_case_alternative_body() {
+    assert_error_span_text(
+        "module Test where\nx = case true of\n  true -> 1\n  false -> \"a\"",
+        "UnificationError",
+        "\"a\""
+    );
+}
+
+#[test]
+fn error_span_array_element_mismatch() {
+    assert_error_span_text(
+        "module Test where\nx = [1, 2, \"three\"]",
+        "UnificationError",
+        "\"three\""
+    );
+}
+
+#[test]
+fn error_span_function_arg_mismatch() {
+    assert_error_span_text(
+        "module Test where\nf :: Int -> Int\nf n = n\nx = f \"hello\"",
+        "UnificationError",
+        "\"hello\""
+    );
+}
+
+#[test]
+fn error_span_if_condition_not_boolean() {
+    assert_error_span_text(
+        "module Test where\nx = if 42 then 1 else 2",
+        "UnificationError",
+        "42"
+    );
+}
+
+#[test]
+fn error_span_case_multiple_alternatives() {
+    assert_error_span_text(
+        "module Test where\nx = case 1 of\n  1 -> \"a\"\n  2 -> \"b\"\n  _ -> true",
+        "UnificationError",
+        "true"
+    );
+}