tighten annotations for some types

Author: rubiojr

compiler/check_mismatch.go

@@ -362,6 +362,60 @@ func compatibleAssignToAnnotation(annot, inferred RugoType) bool {
 	return annot == inferred
 }
 
+// compatibleCallArgToAnnotation is the predicate used at call sites:
+// validating an argument's inferred type against the callee's parameter
+// annotation. It is strict like compatibleAssignToAnnotation (so a
+// `: String` param does NOT silently accept an Integer literal, matching
+// the same rule a `x : String = ...` local variable enforces), with one
+// runtime-coercion carve-out:
+//
+//   - Integer ↔ Float at the call boundary (codegen inserts
+//     rugo_to_int / rugo_to_float wrappers, so numeric values flow
+//     freely between the two annotated numeric types).
+//   - Bool → Integer and Bool → Float (runtime treats bool as 0/1, and
+//     the wrappers above handle the conversion).
+//
+// `Any` annotations and `Unknown`/`Dynamic` inferred types remain
+// silent. Unions are checked member-wise: every member must
+// independently pass, so an Integer|String value can't sneak into a
+// `: Integer` parameter, but Integer|Float into `: Integer` is fine
+// because each member is independently compatible (the second via the
+// numeric carve-out).
+//
+// Use this for call-site checks (literal args, variable args) and for
+// parameter default-value checks. For *return* values, use the
+// permissive compatibleWithAnnotation — codegen really does stringify
+// or coerce-to-bool whatever the return slot needs.
+func compatibleCallArgToAnnotation(annot, inferred RugoType) bool {
+	if inferred == TypeUnknown || inferred == TypeDynamic {
+		return true
+	}
+	switch annot {
+	case TypeDynamic, TypeUnknown:
+		return true
+	}
+	if inferred.IsUnion() {
+		for _, m := range inferred.Members() {
+			if !compatibleCallArgToAnnotation(annot, m) {
+				return false
+			}
+		}
+		return true
+	}
+	if annot == inferred {
+		return true
+	}
+	// Single-bit numeric carve-out: Integer ↔ Float, plus Bool into
+	// either numeric type. Codegen inserts rugo_to_int / rugo_to_float
+	// at the call boundary so the conversion is well-defined.
+	if annot == TypeInt || annot == TypeFloat {
+		if inferred == TypeInt || inferred == TypeFloat || inferred == TypeBool {
+			return true
+		}
+	}
+	return false
+}
+
 // collectLocalAnnots scans a statement list (a function body, top-level
 // program, or test/bench block) for `x : T = expr` bindings and adds
 // them to dst. First-appearance wins (sticky semantics; re-annotation
@@ -451,10 +505,12 @@ func fileFor(f *ast.FuncDef, fallback string) string {
 // (function calls, identifiers) are silently allowed because their value
 // could legitimately match the annotation.
 //
-// The compatibility rule is the *permissive* one (compatibleWithAnnotation),
-// matching what call-site checks use: `string`/`bool`/`any` accept
-// anything, numeric types are mutually compatible, and `nil`/`array`/`hash`
-// only accept their own type.
+// The compatibility rule is the strict-with-numeric-carve-out one
+// (compatibleCallArgToAnnotation), matching call-site checks:
+// `String`/`Bool` annotations only accept their own type, the numeric
+// family (`Integer`/`Float`/`Bool`) flows freely between numeric
+// annotations, and `Any` accepts anything. A `: String` default value
+// of `42` is therefore a guaranteed type-violation.
 //
 // Both top-level FuncDefs and FnExpr lambdas (anywhere they appear) are
 // validated. Nested FuncDefs are reachable through walkStmtExprs's
@@ -560,7 +616,7 @@ func checkParamDefault(p ast.Param, sourceFile string, line int) error {
 	if !isLit {
 		return nil
 	}
-	if compatibleWithAnnotation(annot, litType) {
+	if compatibleCallArgToAnnotation(annot, litType) {
 		return nil
 	}
 	return &ast.UserError{Msg: fmt.Sprintf(

compiler/check_mismatch_calls.go

@@ -18,12 +18,11 @@ import (
 // variable may legitimately hold a value of the annotated type even when
 // the inferrer cannot prove it.
 //
-// The compatibility rule is the permissive one (compatibleWithAnnotation),
-// the same predicate used at return sites: numeric types are mutually
-// compatible, `string` / `bool` annotations accept anything, and `any`
-// accepts anything. This mirrors what codegen actually does at the call
-// boundary (rugo_to_int / rugo_to_float / rugo_to_string / rugo_to_bool
-// coercions and numeric casts).
+// The compatibility rule is compatibleCallArgToAnnotation — strict like
+// the variable-assignment rule (`x : String = 42` errors, and so does
+// `f(x : String); f(42)`), with a numeric carve-out for Integer/Float/Bool
+// because codegen inserts rugo_to_int / rugo_to_float wrappers at the
+// call boundary.
 //
 // Module / method calls (`str.upper(...)`, `obj.method(...)`) are skipped
 // because they have no Rugo-level parameter annotations to compare. Calls
@@ -471,7 +470,7 @@ func (c *callChecker) checkArgs(args []ast.Expr, params []ast.Param, calleeName
 		}
 		// Path 1: literal argument — flag immediately on concrete mismatch.
 		if argType, isLit := literalType(arg); isLit {
-			if compatibleWithAnnotation(annot, argType) {
+			if compatibleCallArgToAnnotation(annot, argType) {
 				continue
 			}
 			return &ast.UserError{Msg: fmt.Sprintf(
@@ -492,7 +491,7 @@ func (c *callChecker) checkArgs(args []ast.Expr, params []ast.Param, calleeName
 		if !argType.IsResolved() {
 			continue
 		}
-		if compatibleWithAnnotation(annot, argType) {
+		if compatibleCallArgToAnnotation(annot, argType) {
 			continue
 		}
 		return &ast.UserError{Msg: fmt.Sprintf(

compiler/check_mismatch_calls_test.go

@@ -158,16 +158,6 @@ def f(a : Float) : Float
   return a + 1.0
 end
 puts(f(2))
-`,
-			shouldError: false,
-		},
-		{
-			name: "Integer literal to string param is permitted",
-			source: `
-def f(a : String) : String
-  return a
-end
-puts(f(42))
 `,
 			shouldError: false,
 		},
@@ -180,18 +170,6 @@ end
 puts(f(nil))
 puts(f("hi"))
 puts(f([1, 2]))
-`,
-			shouldError: false,
-		},
-		{
-			name: "anything to bool-annotated param is permitted",
-			source: `
-def f(a : Bool) : Bool
-  return a
-end
-puts(f(0))
-puts(f("hi"))
-puts(f([1, 2]))
 `,
 			shouldError: false,
 		},
@@ -384,6 +362,192 @@ puts(task.value)
 			wantSubstr:  "cannot pass String literal as argument 1 to 'square'",
 			shouldError: true,
 		},
+		// ---------------------------------------------------------------
+		// Strict call-site rule: String / Bool / Nil params no longer
+		// accept arbitrary types (matches the strict variable-annotation
+		// rule). Numeric carve-out preserved (Int↔Float, Bool→numeric).
+		// ---------------------------------------------------------------
+		{
+			name: "Integer literal to string param is flagged (strict)",
+			source: `
+def f(a : String) : String
+  return a
+end
+puts(f(42))
+`,
+			wantSubstr:  "cannot pass Integer literal as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "Float literal to string param is flagged (strict)",
+			source: `
+def f(a : String) : String
+  return a
+end
+puts(f(3.14))
+`,
+			wantSubstr:  "cannot pass Float literal as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "Bool literal to string param is flagged (strict)",
+			source: `
+def f(a : String) : String
+  return a
+end
+puts(f(true))
+`,
+			wantSubstr:  "cannot pass Bool literal as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "Nil literal to string param is flagged (strict)",
+			source: `
+def f(a : String) : String
+  return a
+end
+puts(f(nil))
+`,
+			wantSubstr:  "cannot pass Nil literal as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "Array literal to string param is flagged (strict)",
+			source: `
+def f(a : String) : String
+  return a
+end
+puts(f([1, 2]))
+`,
+			wantSubstr:  "cannot pass Array literal as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "String literal to bool param is flagged (strict)",
+			source: `
+def f(a : Bool) : Bool
+  return a
+end
+puts(f("hi"))
+`,
+			wantSubstr:  "cannot pass String literal as argument 1 to 'f' (parameter 'a' declared as Bool)",
+			shouldError: true,
+		},
+		{
+			name: "Integer literal to bool param is flagged (strict)",
+			source: `
+def f(a : Bool) : Bool
+  return a
+end
+puts(f(0))
+`,
+			wantSubstr:  "cannot pass Integer literal as argument 1 to 'f' (parameter 'a' declared as Bool)",
+			shouldError: true,
+		},
+		{
+			name: "Array literal to bool param is flagged (strict)",
+			source: `
+def f(a : Bool) : Bool
+  return a
+end
+puts(f([1, 2]))
+`,
+			wantSubstr:  "cannot pass Array literal as argument 1 to 'f' (parameter 'a' declared as Bool)",
+			shouldError: true,
+		},
+		{
+			name: "Tier 3: typed Integer variable to string param is flagged",
+			source: `
+def f(a : String) : String
+  return a
+end
+x : Integer = 42
+puts(f(x))
+`,
+			wantSubstr:  "cannot pass Integer value as argument 1 to 'f' (parameter 'a' declared as String)",
+			shouldError: true,
+		},
+		{
+			name: "Tier 3: typed String variable to bool param is flagged",
+			source: `
+def f(a : Bool) : Bool
+  return a
+end
+x : String = "hi"
+puts(f(x))
+`,
+			wantSubstr:  "cannot pass String value as argument 1 to 'f' (parameter 'a' declared as Bool)",
+			shouldError: true,
+		},
+		// ---------------------------------------------------------------
+		// Numeric carve-out: still permissive at call sites for the
+		// Integer/Float/Bool numeric family.
+		// ---------------------------------------------------------------
+		{
+			name: "Integer literal to float param is permitted (numeric carve-out)",
+			source: `
+def f(a : Float) : Float
+  return a + 1.0
+end
+puts(f(2))
+`,
+			shouldError: false,
+		},
+		{
+			name: "Float literal to int param is permitted (numeric carve-out)",
+			source: `
+def f(a : Integer) : Integer
+  return a + 1
+end
+puts(f(2.5))
+`,
+			shouldError: false,
+		},
+		{
+			name: "Bool literal to int param is permitted (numeric carve-out)",
+			source: `
+def f(a : Integer) : Integer
+  return a + 1
+end
+puts(f(true))
+`,
+			shouldError: false,
+		},
+		// ---------------------------------------------------------------
+		// Any annot still accepts anything.
+		// ---------------------------------------------------------------
+		{
+			name: "anything to any-annotated param is still permitted",
+			source: `
+def f(x : Any) : Any
+  return x
+end
+puts(f(nil))
+puts(f("hi"))
+puts(f([1, 2]))
+`,
+			shouldError: false,
+		},
+		{
+			name: "Same-type matches still pass: String to String",
+			source: `
+def f(s : String) : String
+  return s
+end
+puts(f("hello"))
+`,
+			shouldError: false,
+		},
+		{
+			name: "Same-type matches still pass: Bool to Bool",
+			source: `
+def f(b : Bool) : Bool
+  return !b
+end
+puts(f(true))
+`,
+			shouldError: false,
+		},
 	}
 
 	for _, tc := range cases {