12552e125d
Two silent-miscompile codegen fixes:
0083 — named-const array dimension. `TypeResolver.resolveCompound`'s array
arm resolved the dimension with `if int_literal ... else 0`, so a named const
(`N :: 16; [N]T`) hit the silent `else 0`: the array became 0-length / 0-byte
and element access ran out of bounds (garbage for scalars, bus error for
slice/pointer/struct elements). The arm now delegates the dimension to
`inner.resolveArrayLen` (symmetric with `inner.resolveInner` for the element).
The stateful `Lowering.resolveArrayLen` evaluates it as a compile-time integer
across the comptime-constant / generic-value / module-global const tables and
emits a diagnostic — no fabricated length — when it isn't one.
0084 — `.[...]` literal passed directly as a call arg. `lowerArrayLiteral`
always yields an aggregate array value; the array→slice conversion is the
caller's job. The local-bound var-decl path did it, but the call-arg coercion
path had no array→slice arm, so `classify([N]T, []T)` returned `.none` and the
raw array was passed where a slice was expected (callee read its {ptr,len}
header off the wrong bytes → 0 / garbage / segfault). `classify` now returns a
new `.array_to_slice` plan for same-element `[N]T → []T`, and `coerceToType`
emits the existing `array_to_slice` op — identical to the local-bound path.
Regressions (fail-before/pass-after demonstrated on the pre-fix compiler):
examples/0140-types-named-const-array-dim.sx (s64 + string + struct elems)
examples/0141-types-slice-literal-direct-call-arg.sx (string + []s64)
Gate: zig build, zig build test, bash tests/run_examples.sh (387 passed).
Issues 0083 and 0084 marked RESOLVED.
33 lines
996 B
Plaintext
33 lines
996 B
Plaintext
// A fixed array whose dimension is a module-global named constant
|
|
// (`N :: 16; [N]T`) has the same layout as a literal-dimension array
|
|
// (`[16]T`): correct length and element stride for scalar, slice/pointer
|
|
// (string), and struct element types.
|
|
// Regression (issue 0083): a named-const dim resolved to length 0, giving a
|
|
// 0-byte alloca — scalar reads returned garbage and string/struct elements
|
|
// bus-errored.
|
|
#import "modules/std.sx";
|
|
|
|
N :: 4;
|
|
|
|
P :: struct { x: s64; y: s64; }
|
|
|
|
main :: () {
|
|
// Scalar elements: store then read back.
|
|
a : [N]s64 = ---;
|
|
a[0] = 7;
|
|
a[3] = 42;
|
|
print("scalar a0={} a3={}\n", a[0], a[3]);
|
|
|
|
// Slice/pointer elements (string): used to bus-error.
|
|
s : [N]string = ---;
|
|
s[0] = "hi";
|
|
s[1] = "yo";
|
|
print("string s0={} s1={}\n", s[0], s[1]);
|
|
|
|
// Struct elements.
|
|
ps : [N]P = ---;
|
|
ps[0] = P.{ x = 1, y = 2 };
|
|
ps[2] = P.{ x = 5, y = 6 };
|
|
print("struct p0x={} p0y={} p2x={}\n", ps[0].x, ps[0].y, ps[2].x);
|
|
}
|