a491a1bf73
Attempts 1–4 fixed the array-dimension paths but the same length-0 fabrication class survived on every other site that resolves a compile-time integer. Unify them all on the single shared `program_index.evalConstIntExpr` so they cannot diverge: - All three Vector lane resolvers (resolveTypeCallWithBindings, resolveParameterizedWithBindings, resolveArrayLiteralType) and both generic value-param binders (instantiateGenericStruct, instantiateTypeFunction) hand-rolled an `else => 0` switch. A module-const lane `Vector(N, f32)` fabricated a 0-lane `<0 x float>` (LLVM "huge alignment" abort); a value-param `Vec(N, f32)` fabricated a 0 binding / wrong mangled name. They now fold through the shared evaluator and emit a clean diagnostic + `.unresolved` on a non-const operand (resolveVectorLane / resolveValueParamArg) — never 0. - evalComptimeInt (inline-for bounds) delegated to the shared evaluator, so `inline for 0..M` / `0..(M+1)` fold like array dims. The `<pack>.len` leaf moved into the shared folder via a new `ctx.lookupPackLen`. - The unknown-type semantic checker no longer walks a value-param position (`Vector(N, …)` / `Vec(N, …)`) as a type name (was reporting "unknown type 'N'"). - The parameterized-type-arg parser and the function-body lookahead (hasFnBodyAfterArrow) accept a const-EXPRESSION in a value position, so `Vector(M + 1, f32)` and `[M + 1]T` parse as a return type too (the latter a pre-existing array-dim sibling that the same heuristic broke). Regressions: examples/1501 (named-const + const-expr lane, direct + alias, 3/4-lane reads), 1502 (runtime lane clean-halts, exit 1, no LLVM crash), 0207 (Vec(N)/Vec(M+1) == Vec(3) instantiation), 0610 (inline-for const bounds). Shared-evaluator unit test extended with the pack-len arm. zig build && zig build test && bash tests/run_examples.sh: 395 passed, 0 failed.
17 lines
691 B
Plaintext
17 lines
691 B
Plaintext
// A `Vector` lane count that is not a compile-time integer (here a runtime
|
|
// function call) is a hard error — a clean sx diagnostic with a non-zero exit,
|
|
// NOT a fabricated `<0 x float>` lane that crashes LLVM verification.
|
|
//
|
|
// Regression (issue 0083): the Vector lane resolver hand-rolled an `else => 0`
|
|
// switch that silently fabricated a 0-lane vector for a non-const lane. It now
|
|
// folds the lane through the shared const-int evaluator and, when that yields no
|
|
// compile-time integer, emits this diagnostic and halts the build.
|
|
#import "modules/std.sx";
|
|
|
|
lanes :: () -> u32 { return 3; }
|
|
|
|
main :: () {
|
|
v : Vector(lanes(), f32) = ---;
|
|
print("unreachable: {}\n", v.x);
|
|
}
|