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.
35 lines
1.2 KiB
Plaintext
35 lines
1.2 KiB
Plaintext
// A `.[...]` array/slice literal passed DIRECTLY as a call argument behaves
|
|
// identically to binding it to a typed local first: the literal is
|
|
// materialized into addressable storage and a {ptr,len} slice header is built
|
|
// over it, so the callee reads the element CONTENTS correctly.
|
|
// Regression (issue 0084): a direct literal arg passed the raw array value
|
|
// where a slice was expected, so the callee read its header off the wrong
|
|
// bytes and returned garbage (0).
|
|
#import "modules/std.sx";
|
|
|
|
count_nope :: (xs: []string) -> s64 {
|
|
n := 0;
|
|
i := 0;
|
|
while i < xs.len { if xs[i] == "nope" { n += 1; } i += 1; }
|
|
return n;
|
|
}
|
|
|
|
sum :: (xs: []s64) -> s64 {
|
|
s := 0;
|
|
i := 0;
|
|
while i < xs.len { s += xs[i]; i += 1; }
|
|
return s;
|
|
}
|
|
|
|
main :: () {
|
|
// string slice: direct literal vs local-bound — both see 2 "nope"s.
|
|
print("str direct={}\n", count_nope(.["a", "nope", "b", "nope"]));
|
|
local : []string = .["a", "nope", "b", "nope"];
|
|
print("str local={}\n", count_nope(local));
|
|
|
|
// numeric slice: direct literal vs local-bound — both sum to 100.
|
|
print("num direct={}\n", sum(.[10, 20, 30, 40]));
|
|
nums : []s64 = .[10, 20, 30, 40];
|
|
print("num local={}\n", sum(nums));
|
|
}
|