lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(ir): evalConstFloatExpr reaches parity with evalConstIntExpr — numeric-limit float leaves + float % fold under the unified rule [F0.11]

Browse Source 
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.
This commit is contained in:
agra
2026-06-05 18:15:17 +03:00
parent b73363ca4c
commit 74f675ac0b
9 changed files with 189 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
examples/0168-types-integral-float-to-int.sx
View File

@@ -3,10 +3,14 @@
// `floatToIntExact` rule an array dimension / `$K: Count` already uses — across
// all FIVE sites: a typed LOCAL, a struct FIELD default, a typed module CONST, a
// function PARAM default, and an array DIMENSION. It folds whether written as a
// float LITERAL (`4.0`), an INT-const-EXPRESSION (`M + 2.0`, with `M :: 2`), or a
// float LITERAL (`4.0`), an INT-const-EXPRESSION (`M + 2.0`, with `M :: 2`), a
// FLOAT-const-LEAF expression whose sum is integral (`F + 1.5`, with
// `F : f64 : 2.5`, = 4.0) — including such a float-const-leaf expression driving
// an array dimension directly, through a const, or via a type alias.
// an array dimension directly, through a const, or via a type alias — a builtin
// FLOAT numeric-limit leaf in an integral expression (`f64.max - f64.max` = 0),
// and an integral float `%` (`6.0 % 4.0` = 2). The compile-time float evaluator
// is at parity with the integer one, so integer numeric-limit accessors (`s8.max`,
// `[u8.max]` count) keep folding through the shared int folder, unregressed.
// 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)`).
//
@@ -69,12 +73,32 @@ main :: () {
aa : ArrFE = ---;
print("dim.direct={} dim.const={} dim.alias={}\n", ad.len, ak.len, aa.len);
// Numeric-limit float leaf in an expression: an INTEGRAL result folds (the
// compile-time float evaluator is at parity with the integer one — a
// `f64`/`f32` `.max`/`.min`/`.epsilon`/… leaf is recognised inside an
// expression, not only as a direct value). `f64.max - f64.max` = 0.0 → 0.
lim : s64 = f64.max - f64.max;
// Integral float `%` (parity with int `%`): `6.0 % 4.0` = 2.0 → 2.
fm : s64 = 6.0 % 4.0;
print("limit={} fmod={}\n", lim, fm);
// Integer numeric-limit accessors (NL.1) are unregressed by the float-leaf
// parity work: they still fold at a binding (`s8.max` = 127) and as an array
// dimension count (`[u8.max]` = len 255), through the SAME int folder.
il : s64 = s8.max;
iarr : [u8.max]s64 = ---;
print("intlimit={} intcount={}\n", il, iarr.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).
// including a non-integral const EXPRESSION (`xx (M + 0.5)` → 2), a
// non-integral float-const-LEAF expression (`xx (F + 0.25)` → 2), a
// non-integral numeric-limit expr (`xx (f64.true_min + 0.5)` → 0), and a
// non-integral float `%` (`xx (5.5 % 2.0)` → 1).
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);
xl : s64 = xx (f64.true_min + 0.5);
xm : s64 = xx (5.5 % 2.0);
print("xx={} cast={} xxExpr={} xxFlt={} xxLimit={} xxMod={}\n", e, c, xc, xf, xl, xm);
}

22
examples/1146-diagnostics-nonintegral-float-to-int.sx
View File

@@ -4,13 +4,17 @@
// 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".
// 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).
@@ -36,9 +40,11 @@ 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, ad.len);
print("{} {} {} {} {} {}\n", y, ye, yf, yn, ym, ad.len);
}

4
examples/expected/0168-types-integral-float-to-int.stdout
View File

@@ -4,4 +4,6 @@ field=4 fieldExpr=4 fieldFlt=4
param=6 paramFlt=4
const=8 constFlt=4 len=8
dim.direct=4 dim.const=4 dim.alias=4
xx=4 cast=1 xxExpr=2 xxFlt=2
limit=0 fmod=2
intlimit=127 intcount=255
xx=4 cast=1 xxExpr=2 xxFlt=2 xxLimit=0 xxMod=1

54
examples/expected/1146-diagnostics-nonintegral-float-to-int.stderr
View File

@@ -1,59 +1,71 @@
error: cannot implicitly narrow non-integral float '1.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:36:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:40:16
|
36 | y : s64 = 1.5; // non-integral float LITERAL local → error
40 | y : s64 = 1.5; // non-integral float LITERAL local → error
| ^^^
error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:37:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:41:16
|
37 | ye : s64 = M + 0.5; // non-integral int-const-EXPRESSION local → error
41 | ye : s64 = M + 0.5; // non-integral int-const-EXPRESSION local → error
| ^^^^^^^
error: cannot implicitly narrow non-integral float '2.75' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:38:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:42:16
|
38 | yf : s64 = F + 0.25; // non-integral float-const-LEAF local → error
42 | yf : s64 = F + 0.25; // non-integral float-const-LEAF local → error
| ^^^^^^^^
error: array dimension must be an integer, but '2.75' is a non-integral float
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:39:11
error: cannot implicitly narrow non-integral float '0.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:43:16
|
39 | ad : [F + 0.25]s64 = ---; // non-integral float-const-LEAF array DIMENSION → error
43 | yn : s64 = f64.true_min + 0.5; // non-integral numeric-limit float expr → error
| ^^^^^^^^^^^^^^^^^^
error: cannot implicitly narrow non-integral float '1.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:44:16
|
44 | ym : s64 = 5.5 % 2.0; // non-integral float `%` remainder (1.5) → error
| ^^^^^^^^^
error: array dimension must be an integer, but '2.75' is a non-integral float
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:45:11
|
45 | ad : [F + 0.25]s64 = ---; // non-integral float-const-LEAF array DIMENSION → error
| ^^^^^^^^
error: cannot implicitly narrow non-integral float '3.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:26:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:30:16
|
26 | f : s64 = 3.5; // non-integral float LITERAL field default → error
30 | f : s64 = 3.5; // non-integral float LITERAL field default → error
| ^^^
error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:27:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:31:16
|
27 | fe : s64 = M + 0.5; // non-integral int-const-EXPR field default → error
31 | fe : s64 = M + 0.5; // non-integral int-const-EXPR field default → error
| ^^^^^^^
error: cannot implicitly narrow non-integral float '2.75' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:28:16
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:32:16
|
28 | ff : s64 = F + 0.25; // non-integral float-const-LEAF field default → error
32 | ff : s64 = F + 0.25; // non-integral float-const-LEAF field default → error
| ^^^^^^^^
error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:31:23
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:35:23
|
31 | badLit :: (x : s64 = 2.5) -> s64 { return x; } // non-integral LITERAL param default → error
35 | badLit :: (x : s64 = 2.5) -> s64 { return x; } // non-integral LITERAL param default → error
| ^^^
error: cannot implicitly narrow non-integral float '2.5' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:32:23
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:36:23
|
32 | badExpr :: (x : s64 = M + 0.5) -> s64 { return x; } // non-integral int-const-EXPR param default → error
36 | badExpr :: (x : s64 = M + 0.5) -> s64 { return x; } // non-integral int-const-EXPR param default → error
| ^^^^^^^
error: cannot implicitly narrow non-integral float '2.75' to 's64'; use an explicit cast (`xx`/`cast`)
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:33:23
--> examples/1146-diagnostics-nonintegral-float-to-int.sx:37:23
|
33 | badFlt :: (x : s64 = F + 0.25) -> s64 { return x; } // non-integral float-const-LEAF param default → error
37 | badFlt :: (x : s64 = F + 0.25) -> s64 { return x; } // non-integral float-const-LEAF param default → error
| ^^^^^^^^