// Unified float→int narrowing rule (F0.11), POSITIVE side: an INTEGRAL float
// flowing into an integer-typed binding FOLDS to its integer — the same
// `floatToIntExact` rule an array dimension / `$K: Count` already uses — across
// a typed LOCAL, a struct FIELD default, a typed module CONST, and a function
// PARAM default. It folds whether written as a float LITERAL (`4.0`), an
// INT-const-EXPRESSION (`M + 2.0`, with `M :: 2`), or a FLOAT-const-LEAF
// expression whose sum is integral (`F + 1.5`, with `F : f64 : 2.5`, = 4.0).
// The escape hatch (`xx` / `cast`) still TRUNCATES any float, integral or not —
// including a non-integral const expression (`xx (M + 0.5)` / `xx (F + 0.25)`).
//
// Companion to the negative example 1146 (non-integral floats error).
// Regression (issue 0095): a typed local/param/field silently truncated a float
// initializer (`y : s64 = 1.5` → 1) with no diagnostic; a non-integral const
// EXPRESSION (`M + 0.5`) and a non-integral float-const-LEAF expression
// (`F + 0.25`) truncated even when written through an int binding; the rule now
// folds an integral float (literal, int-const expr, or float-const leaf) and
// rejects a non-integral one.
#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

Box :: struct {
    n  : s64 = 4.0;       // integral float field default → folds to 4
    ne : s64 = M + 2.0;   // integral int-const-EXPR field default → folds to 4
    nf : s64 = F + 1.5;   // integral float-const-LEAF field default → folds to 4
}

withDefault :: (x : s64 = 6.0)     -> s64 { return x; }   // param default → 6
withFlt     :: (x : s64 = F + 1.5) -> s64 { return x; }   // float-const-leaf param default → 4

K  : s64 : 8.0;          // integral float module const → folds to 8
KF : s64 : F + 1.5;      // integral float-const-LEAF module const → folds to 4

main :: () {
    // Typed local: integral float folds (literal + int-const expr + float-const leaf).
    z : s64 = 4.0;
    ze : s64 = M + 2.0;
    zf : s64 = F + 1.5;
    print("local={} localExpr={} localFlt={}\n", z, ze, zf);

    // Negative integral float folds to its (negative) integer.
    neg : s64 = -2.0;
    print("neg={}\n", neg);

    // Struct field defaults fold (literal + int-const expr + float-const leaf).
    b := Box.{};
    print("field={} fieldExpr={} fieldFlt={}\n", b.n, b.ne, b.nf);

    // Param defaults fold.
    print("param={} paramFlt={}\n", withDefault(), withFlt());

    // Module consts fold (and an integral float const can drive an array dim: len 8).
    a : [K]s64 = ---;
    print("const={} constFlt={} len={}\n", K, KF, a.len);

    // Explicit escape: `xx` / `cast` always truncate, integral or not —
    // including a non-integral const EXPRESSION (`xx (M + 0.5)` → 2) and a
    // non-integral float-const-LEAF expression (`xx (F + 0.25)` → 2).
    e : s64 = xx 4.9;
    c : s64 = cast(s64) 1.5;
    xc : s64 = xx (M + 0.5);
    xf : s64 = xx (F + 0.25);
    print("xx={} cast={} xxExpr={} xxFlt={}\n", e, c, xc, xf);
}