b73363ca4c
The compile-time count fold (array dimension / Vector lane / value-param) was
integer-only: it folded a DIRECT integral float literal (`[4.0]`, `[N]` with
`N : f64 : 4.0`) but rejected an INTEGRAL expression built from a non-integral
float-const leaf (`[F + 1.5]` = 4.0, `F : f64 : 2.5`) — and a const folded from
one (`[K]` with `K : s64 : F + 1.5`) — as "must be a compile-time integer
constant". This was the last of issue 0095's five narrowing sites (local /
field / param / const / array-dim) still diverging.
Route the count fold through the SAME compile-time float evaluation the other
four sites use:
- New `program_index.foldCountI64` — the single int-or-integral-float count
fold: `evalConstIntExpr` first, then (only on failure) `evalConstFloatExpr` +
`floatToIntExact`. `foldDimU32` (dim/lane/u32 value-param), the non-u32
value-param gate, and `emitModuleConst`'s integer-const materialization all
delegate to it, so a const's emitted value and its use as a count come from
one fold (no parallel integral check, no two-resolver divergence — issue 0083).
- New `DimU32.non_integral_float` variant carries a non-integral float dim to a
distinct, accurate diagnostic ("array dimension must be an integer, but '2.75'
is a non-integral float") — the cast-escape advice the binding sites give does
not apply in a count position, so the dim wording omits it. `reportDimError`,
the Vector-lane resolver, and the top-level array-alias diagnostic all handle
the new variant, so the DIRECT and type-ALIAS forms emit the identical message.
- `type_bridge.StatelessInner.lookupFloatName` (via `moduleConstFloat`) is the
float twin of its `lookupDimName`, so the registration-time alias path folds a
float-const-leaf dimension to the SAME count as the stateful direct path.
`inline for` range bounds are spec endpoints, not counts (specs.md §2), so they
keep the int-only fold deliberately (no silent-truncation bug there).
Relaxes the F0.4 `examples/1132` wording: a non-integral float const dim now
reports the precise "non-integral float" message (it still errors).
Regression: 0168 (positive — `[F + 1.5]s64`, `[KF]s64`, alias `ArrFE` all fold
to len 4), 1146 (negative — `[F + 0.25]s64` errors), 1132 (precise wording), and
a `foldCountI64`/`foldDimU32` unit test. issues/0095 marked RESOLVED (attempt 4).
specs.md + readme.md state the unified rule across all five sites.
45 lines
2.5 KiB
Plaintext
45 lines
2.5 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`), 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 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, and combinations). 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
|
|
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, ad.len);
|
|
}
|