Include argument and actual types in type errors

Author: mgomes

ROADMAP.md

@@ -198,7 +198,7 @@ Goal: make types expressive enough for real workflows while keeping runtime chec
 ### v0.15.0 Definition of Done
 
 - [ ] Existing scripts without annotations remain compatible.
-- [ ] Type errors include parameter name, expected type, and actual type.
+- [x] Type errors include parameter name, expected type, and actual type.
 - [ ] Capability contract validation can use the same type primitives.
 
 ---

vibes/execution.go

@@ -715,7 +715,7 @@ func (exec *Execution) callFunction(fn *ScriptFunction, receiver Value, args []V
 	}
 	if fn.ReturnTy != nil {
 		if err := checkValueType(val, fn.ReturnTy); err != nil {
-			return NewNil(), exec.errorAt(pos, "%s", err.Error())
+			return NewNil(), exec.errorAt(pos, "%s", formatReturnTypeMismatch(fn.Name, err))
 		}
 	}
 	if returned {
@@ -3247,7 +3247,7 @@ func (exec *Execution) bindFunctionArgs(fn *ScriptFunction, env *Env, args []Val
 
 		if param.Type != nil {
 			if err := checkValueType(val, param.Type); err != nil {
-				return exec.errorAt(pos, "%s", err.Error())
+				return exec.errorAt(pos, "%s", formatArgumentTypeMismatch(param.Name, err))
 			}
 		}
 		env.Define(param.Name, val)
@@ -3280,7 +3280,35 @@ func checkValueType(val Value, ty *TypeExpr) error {
 	if matches {
 		return nil
 	}
-	return fmt.Errorf("expected %s", formatTypeExpr(ty))
+	return &typeMismatchError{
+		Expected: formatTypeExpr(ty),
+		Actual:   val.Kind().String(),
+	}
+}
+
+type typeMismatchError struct {
+	Expected string
+	Actual   string
+}
+
+func (e *typeMismatchError) Error() string {
+	return fmt.Sprintf("expected %s, got %s", e.Expected, e.Actual)
+}
+
+func formatArgumentTypeMismatch(name string, err error) string {
+	var mismatch *typeMismatchError
+	if errors.As(err, &mismatch) {
+		return fmt.Sprintf("argument %s expected %s, got %s", name, mismatch.Expected, mismatch.Actual)
+	}
+	return fmt.Sprintf("argument %s type check failed: %s", name, err.Error())
+}
+
+func formatReturnTypeMismatch(fnName string, err error) string {
+	var mismatch *typeMismatchError
+	if errors.As(err, &mismatch) {
+		return fmt.Sprintf("return value for %s expected %s, got %s", fnName, mismatch.Expected, mismatch.Actual)
+	}
+	return fmt.Sprintf("return type check failed for %s: %s", fnName, err.Error())
 }
 
 func valueMatchesType(val Value, ty *TypeExpr) (bool, error) {
@@ -3677,7 +3705,7 @@ func (s *Script) Call(ctx context.Context, name string, args []Value, opts CallO
 	}
 	if fn.ReturnTy != nil {
 		if err := checkValueType(val, fn.ReturnTy); err != nil {
-			return NewNil(), err
+			return NewNil(), exec.errorAt(fn.Pos, "%s", formatReturnTypeMismatch(fn.Name, err))
 		}
 	}
 	if err := exec.checkMemoryWith(val); err != nil {

vibes/integration_test.go

@@ -592,8 +592,16 @@ func TestTypeErrorCases(t *testing.T) {
 	if err == nil {
 		t.Fatalf("arg_type_mismatch: expected error")
 	}
-	if !strings.Contains(err.Error(), "expected int") {
-		t.Fatalf("arg_type_mismatch: unexpected error '%v', want 'expected int'", err)
+	if !strings.Contains(err.Error(), "argument n expected int, got string") {
+		t.Fatalf("arg_type_mismatch: unexpected error '%v', want argument+expected+actual", err)
+	}
+
+	_, err = script.Call(context.Background(), "return_type_mismatch", nil, CallOptions{})
+	if err == nil {
+		t.Fatalf("return_type_mismatch: expected error")
+	}
+	if !strings.Contains(err.Error(), "return value for return_type_mismatch expected int, got string") {
+		t.Fatalf("return_type_mismatch: unexpected error '%v', want expected+actual", err)
 	}
 }
 

vibes/runtime_test.go

@@ -1270,47 +1270,53 @@ func TestTypedFunctions(t *testing.T) {
 	}
 
 	_, err = script.Call(context.Background(), "pick_second", []Value{NewString("bad"), NewInt(2)}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected int") {
-		t.Fatalf("expected type error, got %v", err)
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument n expected int, got string") {
+		t.Fatalf("expected argument type error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "bad_return", []Value{NewInt(1)}, CallOptions{})
 	if err == nil {
 		res, _ := script.Call(context.Background(), "bad_return", []Value{NewInt(1)}, CallOptions{})
 		t.Fatalf("expected return type error, got value %v (%v)", res, res.Kind())
 	}
-	if !strings.Contains(err.Error(), "expected int") {
+	if !strings.Contains(err.Error(), "return value for bad_return expected int, got string") {
 		t.Fatalf("expected return type error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "union_echo", []Value{NewBool(true)}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected int | string") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument v expected int | string, got bool") {
 		t.Fatalf("expected union arg type error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "union_bad_return", nil, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected int | string") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "return value for union_bad_return expected int | string, got bool") {
 		t.Fatalf("expected union return type error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "ints_only", []Value{
 		NewArray([]Value{NewInt(1), NewString("oops")}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected array<int>") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument values expected array<int>, got array") {
 		t.Fatalf("expected typed array arg error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "totals_by_player", []Value{
 		NewHash(map[string]Value{"alice": NewString("oops")}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected hash<string, int>") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument totals expected hash<string, int>, got hash") {
 		t.Fatalf("expected typed hash arg error, got %v", err)
 	}
 
 	_, err = script.Call(context.Background(), "mixed_items", []Value{
 		NewArray([]Value{NewBool(true)}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected array<int | string>") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument values expected array<int | string>, got array") {
 		t.Fatalf("expected typed union array arg error, got %v", err)
 	}
 
@@ -1321,7 +1327,8 @@ func TestTypedFunctions(t *testing.T) {
 			"role":  NewString("captain"),
 		}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected { active: bool?, id: string, score: int }") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument payload expected { active: bool?, id: string, score: int }, got hash") {
 		t.Fatalf("expected shape extra-field error, got %v", err)
 	}
 
@@ -1332,7 +1339,8 @@ func TestTypedFunctions(t *testing.T) {
 			"active": NewBool(true),
 		}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected { active: bool?, id: string, score: int }") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument payload expected { active: bool?, id: string, score: int }, got hash") {
 		t.Fatalf("expected shape field-type error, got %v", err)
 	}
 
@@ -1346,7 +1354,8 @@ func TestTypedFunctions(t *testing.T) {
 			}),
 		}),
 	}, CallOptions{})
-	if err == nil || !strings.Contains(err.Error(), "expected array<{ id: string, stats: { wins: int } }>") {
+	if err == nil ||
+		!strings.Contains(err.Error(), "argument rows expected array<{ id: string, stats: { wins: int } }>, got array") {
 		t.Fatalf("expected nested shape error, got %v", err)
 	}
 }