74f675ac0b
The compile-time float evaluator lagged the integer one: it had no numeric-limit field-access arm, so `y : s64 = f64.true_min + 0.5` (=0.5) silently truncated to 0 even though the direct `f64.true_min` already errored; the arm-by-arm audit also found a missing `%` arm, so `y : s64 = 5.5 % 2.0` (=1.5) silently truncated to 1. Bring evalConstFloatExpr to PARITY with evalConstIntExpr: - Add a `.field_access` arm resolving a builtin FLOAT numeric-limit accessor (`f64.max`, `f32.epsilon`, `f64.true_min`, …) via the SAME `type_resolver.floatLimitFor` that `lowerNumericLimit` uses — the float twin of the int evaluator's `integerLimitFor` arm. - Add a `.mod` arm via `@rem` (matching evalConstIntExpr and codegen's `frem`): `6.0 % 4.0` folds to 2 (via int delegation), `5.5 % 2.0` = 1.5 is rejected. The two evaluators now share every leaf/operator shape, so no compile-time-const float form escapes the unified float→int rule at one site while folding at another. All five sites (local/field/param/const/ array-dim) stay consistent. Regression: 0168 (positive) adds `f64.max - f64.max` → 0, `6.0 % 4.0` → 2, integer-limit `s8.max`/`[u8.max]` unregressed, `xx` escapes for both new forms; 1146 (negative) adds `f64.true_min + 0.5` and `5.5 % 2.0` erroring at a binding site; program_index.test.zig covers the floatLimitFor arm and the `%` arm. specs.md + readme.md state the parity. issues/0095 RESOLVED banner gains the attempt-5 entry.
51 lines
3.0 KiB
Plaintext
51 lines
3.0 KiB
Plaintext
// 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, a struct FIELD default, AND an array DIMENSION; 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`), a FLOAT-const-leaf expression (`F + 0.25`, with `F : f64 : 2.5`,
|
|
// = 2.75), a builtin FLOAT numeric-limit leaf inside an expression
|
|
// (`f64.true_min + 0.5` = 0.5), or a float `%` whose remainder is non-integral
|
|
// (`5.5 % 2.0` = 1.5) — all of these are the core of issue 0095, which previously
|
|
// slipped through and truncated. The fix is the integral-fold / non-integral-error
|
|
// rule shared across all five sites (local, field, param, const, and array
|
|
// dimension), applied to ANY compile-time-constant float expression (literal,
|
|
// int-const leaf, float-const leaf, numeric-limit leaf, `+ - * / %`, and
|
|
// combinations) — the compile-time float evaluator is at parity with the integer
|
|
// one, so no float leaf shape escapes. The array-dimension site phrases the same
|
|
// rejection as "must be an integer".
|
|
//
|
|
// 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
|
|
yn : s64 = f64.true_min + 0.5; // non-integral numeric-limit float expr → error
|
|
ym : s64 = 5.5 % 2.0; // non-integral float `%` remainder (1.5) → error
|
|
ad : [F + 0.25]s64 = ---; // non-integral float-const-LEAF array DIMENSION → error
|
|
b := Bad.{};
|
|
print("{} {} {}\n", b.f, b.fe, b.ff);
|
|
print("{} {} {}\n", badLit(), badExpr(), badFlt());
|
|
print("{} {} {} {} {} {}\n", y, ye, yf, yn, ym, ad.len);
|
|
}
|