e442cdf5e7
The shared compile-time integer folder (`evalConstIntExpr`) accepts an integral float literal/const as an integer leaf (`[4.0]` → 4) and then applied INTEGER arithmetic to the whole expression — so `5.0 / 2.0` folded as `divTrunc(5,2)` = 2 instead of float division (`2.5`). The bug fired at all FIVE unified-rule sites (typed local, field default, param default, typed const, array dimension), because the typed sites evaluate through `evalConstFloatExpr` (which delegates the node to the int folder) and the count sites through `foldCountI64` (int folder first). Fix at the single root: `evalConstIntExpr`'s `.div` arm refuses to fold a division whose lhs/rhs is float-valued (`isFloatValuedExpr`), so the value surfaces through `evalConstFloatExpr` + the unified rule — an integral quotient (`6.0 / 2.0` → 3) folds, a non-integral one (`5.0 / 2.0` = 2.5, mixed `5 / 2.0`, float-const `F / G`) errors. Genuine integer `/` (`5 / 2` → 2) is unchanged; `*`/`+`/`-` need no guard (they agree between int and float for the integral operands the int folder ever sees). `isFloatValuedExpr` judges a const-leaf by VALUE (`moduleConstIsFloatTyped` recurses into the const's value with the existing cycle-guard frame), so an untyped float-EXPRESSION const (`ME :: 4.0 + 1.0`, placeholder type s64) is caught at both the count path and — via `foldComptimeFloatInit`'s guard — the typed-binding path. A backtick RAW receiver (`` `f64.epsilon ``) is a field read, not a float limit (is_raw check, issues 0092/0093). Regression: examples/1147 (negative — `5.0 / 2.0` errors at all five sites plus untyped float-EXPR const div); 0168 extended (positive — `6.0 / 2.0`, `12.0 / 4.0`, `[6.0/2.0]`, `xx (5.0/2.0)` → 2); unit tests "the int folder refuses a FLOAT division" and "moduleConstIsFloatTyped judges a const by VALUE". specs.md + readme.md state the float-`/` rule.
47 lines
2.5 KiB
Plaintext
47 lines
2.5 KiB
Plaintext
// Unified float→int narrowing rule (F0.11), float-DIVISION pin: a compile-time
|
|
// float division (`5.0 / 2.0` = 2.5) is a NON-INTEGRAL float, so narrowing it
|
|
// implicitly into an integer-typed binding is a COMPILE ERROR — exactly like any
|
|
// other non-integral float (example 1146). The division is the subtle case: its
|
|
// operands (`5.0`, `2.0`) are individually INTEGRAL, so a naive integer fold
|
|
// would truncate `5.0 / 2.0` to 2 with no diagnostic. The rule fires at all five
|
|
// sites — a typed module CONST, a struct FIELD default, a function PARAM default,
|
|
// a typed LOCAL, and an array DIMENSION — because the shared compile-time integer
|
|
// folder now refuses a division with a float operand, deferring it to the float
|
|
// evaluator + the unified rule (integral folds, non-integral errors). A float
|
|
// operand on either side (literal or float-typed const) makes the `/` a float
|
|
// division.
|
|
//
|
|
// The escape hatch stays open: `xx (5.0 / 2.0)` truncates to 2 with no error, and
|
|
// an INTEGRAL float division (`6.0 / 2.0` → 3) folds — both exercised on the
|
|
// POSITIVE side (example 0168).
|
|
//
|
|
// Regression (issue 0095, F0.11-6): `5.0 / 2.0` at a typed local, field default,
|
|
// param default, typed const, and array dimension all silently folded to 2 via
|
|
// integer truncating division; each now rejects the non-integral float.
|
|
#import "modules/std.sx";
|
|
|
|
// An UNTYPED float-EXPRESSION const carries a placeholder `s64` type, yet its
|
|
// value is float — `ME / 2` is still float division and must reject (judged by
|
|
// the const's VALUE, not its declared type), at BOTH the typed-binding path and
|
|
// the count path.
|
|
ME :: 4.0 + 1.0; // untyped float-EXPRESSION const (= 5.0)
|
|
|
|
// Typed CONST: declared but not referenced, so the single narrowing error is not
|
|
// followed by a downstream "unresolved const" cascade.
|
|
K : s64 : 5.0 / 2.0; // 2.5 non-integral float-DIVISION const → error
|
|
|
|
BadField :: struct {
|
|
f : s64 = 5.0 / 2.0; // non-integral float-DIVISION field default → error
|
|
}
|
|
|
|
badParam :: (x : s64 = 5.0 / 2.0) -> s64 { return x; } // float-DIVISION param default → error
|
|
|
|
main :: () {
|
|
local : s64 = 5.0 / 2.0; // non-integral float-DIVISION local → error
|
|
dim : [5.0 / 2.0]s64 = ---; // non-integral float-DIVISION array dimension → error
|
|
cdiv : s64 = ME / 2; // untyped float-EXPR const division (5.0/2 = 2.5) → error
|
|
cdim : [ME / 2]s64 = ---; // same, at the count path → error
|
|
b := BadField.{};
|
|
print("{} {} {} {} {} {}\n", local, b.f, badParam(), dim.len, cdiv, cdim.len);
|
|
}
|