A float literal outside its type's range is accepted: f32 a <- 1e39f32 emits 1e39f, which gcc -Werror rejects (exit 0) #2002

The defect

A float literal whose value is outside its type's range transpiles with exit 0 on every target. The generated C then fails the -Werror compile that every fixture cell uses, or holds a different value from the one written.

Measured on main at 0cd96994b with npx tsx src/cli/index.ts <file> --target host, then gcc -c -O3 -Wall -Wextra -Werror (the // test-no-warnings flags). g++ -x c++ with the same flags gives the same errors.

Without -Werror, the first three only warn, and the program holds inf or 0.0f where it wrote 1e39, 1e-50 or 1e309. The fourth is an f64 literal converted to float. C11 6.3.1.5p1 leaves the conversion of a value outside the destination's range undefined, and Annex F gives inf.

Controls (in range, must stay accepted): f32 ok1 <- 3.4e38f32; and f32 ok2 <- 1e-38f32; transpile with exit 0 and compile cleanly under the same flags.

Reproduction

suffixed.cnx:

f32 a <- 1e39f32;
u32 main() {
    if (a < 1.0f32) { return 1; }
    return 0;
}

npx tsx src/cli/index.ts suffixed.cnx --target host   # exit 0
gcc -c -O3 -Wall -Wextra -Werror suffixed.c           # error: floating constant exceeds range of 'float'

What needs deciding

No ADR decides this. E0868 (ADR-024) rejects an integer literal that does not fit its target's range. ADR-044 "Floating Point Literals" says only that an unsuffixed literal is f64 and that narrowing it to f32 "loses precision". It says nothing about a value outside the type's range, or one that rounds to zero.

Related

• An array larger than the target's address space, or an f64 literal a 32-bit double cannot hold, is accepted for AVR #1766: the same class for an f64 literal on AVR, whose double is 32 bits, so that case depends on the target. These rows fail on every target, because f32's range is the same on every catalog row.
• An f64 value narrows to f32 silently at every conversion site: f32 x <- m with f64 m is exit 0, while u8 <- u16 is E0869 #1910: an f64 value narrows to f32 silently at every conversion site. Row 4 is the literal case of that narrowing.
• Found while reviewing PR fix(#1268): E0800/E0802 see a this./global./Scope.-qualified zero const #1990. Its constant evaluator folds f32 literals, so k / 1e-50f32 reports E0800 there, which matches C's 0.0f.

Definition of done

• The owner decides, in ADR-044 or ADR-024, whether a float literal outside its type's range is a transpile-time diagnostic. That covers overflow to inf and rounding to zero, for a suffixed literal and for an unsuffixed literal converted to f32.
• Each row above either has that diagnostic, with a test-error fixture that keeps the in-range controls beside it, or has a reason recorded here for leaving it to the C compiler.
• Mutation-checked: removing the check turns the fixture red.