1f9f944ca1
Makes the F0.4 fixes exhaustive across every resolution / nesting path.
0083 — named-const array dimension, stateless paths. Attempt 1 fixed the
stateful resolver (direct local decls, struct fields, params, returns) but the
binding-free registration-time resolver (`type_bridge`, used for type aliases
`Arr :: [N]T` and inline union/enum field types) still resolved a named dim with
a silent `else 0`, so `Arr :: [N]s64; a : Arr` and `union { a: [N]s64 }` were
still miscompiled (garbage / bus error). Thread the module-global const table
(`ProgramIndex.module_const_map`) into `type_bridge` alongside the alias map, so
`StatelessInner.resolveArrayLen` resolves a named module-const dim to the same
length everywhere. The remaining unresolvable case (a computed/comptime dim on
the binding-free path, which the stateful path hard-errors) now bails LOUDLY
instead of fabricating a 0 length.
0085 — nested slice-literal elements. `lowerArrayLiteral` lowered each element
with the element type as target but appended the raw value. A nested `.[...]`
element at a slice element type (`[][]s64`) still lowers to an aggregate array
`[N]T`, so the outer aggregate held raw arrays where slice {ptr,len} headers
were expected — indexing the inner slice read a garbage pointer and segfaulted.
After lowering each element, coerce a same-element array to the slice element
type via the existing `array_to_slice` op. The coercion recurses with the
nesting, so `[][]T` and deeper materialize at every level — local-bound AND
direct-call-argument forms.
Regressions (fail-before/pass-after demonstrated on the pre-fix compiler):
examples/0140-types-named-const-array-dim.sx — extended with type-alias,
nested [N][M]T, and union-field named dims (s64 / string / struct elems)
examples/0142-types-nested-slice-literal-elements.sx — [][]s64 + [][]string,
local-bound vs direct-arg
src/ir/type_bridge.test.zig — named-const dim resolves to literal length
Gate: zig build, zig build test, bash tests/run_examples.sh (388 passed).
Issues 0083 and 0085 marked RESOLVED.
2.6 KiB
0085 — nested slice literal elements are stored as raw arrays
RESOLVED. Root cause:
Lowering.lowerArrayLiterallowered each element with the element type astarget_typebut appended the returned value directly. For a nested.[...]element whose expected element type is a slice ([]T), the inner literal still lowers to an aggregate ARRAY[N]T— so the outer aggregate (typed array-of-[]T) held raw arrays where slice {ptr,len} headers were expected; indexing the inner slice read a garbage pointer and segfaulted. Fix: after lowering each element, when the element type is a slice and the lowered value is a same-element array, coerce it via the existingarray_to_sliceop (materialize backing storage + build the header) — identical to the whole- literal coercion the var-decl / call-arg paths already run. The coercion recurses with the nesting, so[][]Tand deeper materialize at every level. Files:src/ir/lower.zig(lowerArrayLiteral). Regression:examples/0142-types-nested-slice-literal-elements.sx([][]s64+[][]string, local-bound AND direct-call-argument forms).
Symptom
Nested array/slice literals such as .[.[1, 2], .[3, 4]] miscompile when the
expected element type is a slice ([][]s64). Observed: both the local-bound and
direct-call forms segfault while indexing the inner slice. Expected: both forms
materialize each inner [N]T literal as a []T slice and print the same value.
Reproduction
#import "modules/std.sx";
sum_nested :: (xss: [][]s64) -> s64 {
return xss[0][1] + xss[1][0];
}
main :: () {
local : [][]s64 = .[.[1, 2], .[3, 4]];
print("local={}\n", sum_nested(local));
print("direct={}\n", sum_nested(.[.[1, 2], .[3, 4]]));
}
Observed on flow/sx-foundation/F0.4: segfault at address 0x9 before either
line prints. Expected output:
local=5
direct=5
Investigation prompt
Fix nested slice literal materialization. The likely area is
src/ir/lower.zig in Lowering.lowerArrayLiteral: the outer literal can know
its expected element type is []T, and the loop sets self.target_type = elem_ty while lowering each inner literal, but it appends the returned value
directly. For an inner .[...], that returned value is still an array aggregate
[N]T, not the target []T slice. Add per-element coercion/materialization
after lowering each element, using the element source type and expected
elem_ty (the existing array_to_slice coercion should be reused). Verify the
repro prints local=5 and direct=5, then run zig build && zig build test && bash tests/run_examples.sh.