sx/issues/0095-typed-local-float-int-narrowing.md

0095 — typed local/decl silently truncates a float initializer to an integer annotation

RESOLVED (F0.11). Agra ruled the UNIFIED rule (Option B): an implicit float→int in a typed binding behaves exactly like the array-dimension rule — an integral float FOLDS to its integer (4.0 → 4, -2.0 → -2), a non-integral float is a COMPILE ERROR (1.5, 4.5), and an explicit xx / cast(T) ALWAYS truncates (the escape). Applied consistently across typed local / param-default / field-default, typed module CONST, and array dim — all reusing the single program_index.floatToIntExact / evalConstIntExpr facility (no second integral check).

Fix (src/ir/lower.zig, src/ir/module.zig, src/ir/program_index.zig):

• Builder.constFloatInfo reads a compile-time const_float back from its Ref (value + span).
• coerceToType now means IMPLICIT coercion: its .float_to_int arm folds an integral const-float to constInt, else emits the narrowing diagnostic. coerceExplicit is the raw truncating path; xx (lowerXX) and cast(T) route through it so the escape still truncates.
• Field-default lowering (struct-literal pad, named-field default, buildDefaultValue) now coerces the default to the field type at the IR level (was silently bit-coerced by emitStructInit).
• Const path: typedConstInitFits accepts an integral float (literal or a M + 2.0-style expression that folds via evalComptimeInt); emitModuleConst / constExprValue / globalInitValue fold an integral float to its int and reject a non-integral one.

Completion (F0.11 attempt 2) — the direct-const_float coerce arm only caught a float LITERAL; a non-integral const-folded float EXPRESSION (local/field/param : s64 = M + 0.5) still truncated silently. Closed by:

• New program_index.evalConstFloatExpr — the f64 counterpart to evalConstIntExpr, delegating every integer subtree back to it (no parallel integer logic), adding only the float literal / negate / + - * / arms.
• Lowering.foldComptimeFloatInit routes the typed LOCAL, struct FIELD default, and call ARGUMENT (incl. an expanded param default) through evalConstFloatExpr + floatToIntExact: an integral comptime float folds, a non-integral one errors, a genuine runtime float / xx cast is left to the normal path. (Run pure evalConstFloatExpr FIRST so a $pack[i] arg isn't spuriously type-resolved out of binding.)
• One Lowering.diagNonIntegralNarrow now emits the narrowing wording at all five sites (coerce arm, global init, const-expr value, the typed-binding sites, and the typed-const path), so the typed-CONST non-integral diagnostic reads cannot implicitly narrow non-integral float … instead of the stale initializer is a float literal / floating-point expression.

Regression tests: examples/0168-types-integral-float-to-int.sx (positive — local/field/param/const fold, integral const-EXPRESSION (M + 2.0) folds, xx/cast truncate incl. xx (M + 0.5)), examples/1146-diagnostics- nonintegral-float-to-int.sx (negative — non-integral LITERAL and const- EXPRESSION error at local/param/field), the integral-float const cases in examples/0162-types-typed-module-const-roundtrip.sx, and the aligned const diagnostic in examples/1143-diagnostics-typed-module-const-mismatch.sx (G / BAD / BAD2 stay errors with the new wording). Unit: program_index.test.zig "evalConstFloatExpr folds comptime float expressions".

Symptom

A typed LOCAL (and likely typed param/field) silently truncates a floating-point initializer to an integer annotation instead of rejecting or requiring an explicit cast.

Observed:

• y : s64 = 1.5; → y == 1 (float literal truncated, no diagnostic)
• y : s64 = 2 + 0.5; → y == 2 (float-valued expr truncated, no diagnostic)

Expected: a type-mismatch / narrowing diagnostic (consistent with typed MODULE CONSTS, which after F0.7 reject N : s64 : 1.5 and N : s64 : M + 0.5). Today consts are strict but locals are lenient — an inconsistency.

Reproduction

#import "modules/std.sx";
main :: () {
    y : s64 = 1.5;
    print("{}\n", y);   // prints 1
}

Investigation prompt

Decide + implement the language rule for implicit float→int narrowing in a TYPED binding (local / param / field) initializer. Module consts already reject it (F0.7, registerTypedModuleConst + typedConstInitFits/constExprInitFits). Make typed-local/param/field assignment-coercion consistent: either reject a non-integral float→int initializer with a diagnostic (matching the const path) or require an explicit xx/cast. Suspected area: the assignment / typed-binding coercion path (coerceToType ladder, specs.md §"coercion") in src/ir/lower.zig. Verify y : s64 = 1.5 errors (or requires a cast); confirm integral-float folding rules (specs.md: 4.0→4 ok, 4.5 rejected) stay consistent. Then gate.

Disposition

Discovered during F0.7 (issue 0088) attempt-2 review. Agra ruled F0.7 fixes the inferExprType ROOT for binary-op promotion; this typed-LOCAL narrowing is a SEPARATE assignment-coercion concern -> its own scheduled step.