// Unified float→int narrowing rule (F0.11), NEGATIVE side: a NON-INTEGRAL float
// implicitly narrowing to an integer-typed binding is a COMPILE ERROR — not a
// silent truncation. The rule fires at a typed LOCAL initializer, a function
// PARAM default, and a struct FIELD default; each emits a narrowing diagnostic
// at the offending float and aborts (exit 1). It fires whether the float is a
// LITERAL (`1.5`), an INT-const-expression (`M + 0.5`, with `M :: 2`), or a
// FLOAT-const-leaf expression (`F + 0.25`, with `F : f64 : 2.5`, = 2.75) — all
// three are the core of issue 0095, which previously slipped through and
// truncated to 2. The fix is the integral-fold / non-integral-error rule shared
// with the array-dimension path, applied to ANY compile-time-constant float
// expression (literal, int-const leaf, float-const leaf, and combinations).
//
// The escape hatch stays open: `y : s64 = xx 1.5` (or `cast(s64) 1.5`)
// truncates with no error — exercised on the POSITIVE side (example 0168).
//
// Regression (issue 0095): `y : s64 = 1.5` silently truncated to 1,
// `y : s64 = M + 0.5` to 2, and `y : s64 = F + 0.25` (float-const leaf) to 2.
#import "modules/std.sx";

M :: 2;          // int module const, for the INT-const-EXPRESSION cases
F : f64 : 2.5;   // float module const, for the FLOAT-const-LEAF cases

Bad :: struct {
    f  : s64 = 3.5;       // non-integral float LITERAL field default → error
    fe : s64 = M + 0.5;   // non-integral int-const-EXPR field default → error
    ff : s64 = F + 0.25;  // non-integral float-const-LEAF field default → error
}

badLit  :: (x : s64 = 2.5)      -> s64 { return x; }   // non-integral LITERAL param default → error
badExpr :: (x : s64 = M + 0.5)  -> s64 { return x; }   // non-integral int-const-EXPR param default → error
badFlt  :: (x : s64 = F + 0.25) -> s64 { return x; }   // non-integral float-const-LEAF param default → error

main :: () {
    y  : s64 = 1.5;       // non-integral float LITERAL local → error
    ye : s64 = M + 0.5;   // non-integral int-const-EXPRESSION local → error
    yf : s64 = F + 0.25;  // non-integral float-const-LEAF local → error
    b := Bad.{};
    print("{} {} {}\n", b.f, b.fe, b.ff);
    print("{} {} {}\n", badLit(), badExpr(), badFlt());
    print("{} {} {}\n", y, ye, yf);
}