da1063f1bb
Building on the Option 3 lvalue-borrow rule, the long-lived allocators
in `library/modules/allocators.sx` (GPA, Arena, TrackingAllocator) now
return their state by value instead of via a heap-allocated `*T`. The
caller binds the result to a local; the local IS the allocator state.
`xx local` borrows that storage under Option 3, so the `Allocator`
protocol value's `ctx` points at the local — no heap allocation for
the state struct, no `free` of the state needed.
```sx
gpa := GPA.init(); // GPA (value)
arena := Arena.init(xx gpa, 4096); // Arena (value)
tracker := TrackingAllocator.init(xx gpa); // TrackingAllocator (value)
push Context.{ allocator = xx tracker, data = null } { ... }
```
Why by-value:
- One fewer `libc_malloc` per allocator instance.
- No state-struct leak. The local is reclaimed at scope exit; `deinit`
only handles downstream resources (chunks, etc.) — not its own struct.
- Owning structs can embed allocators as value fields directly.
Callsite changes:
- `library/modules/ui/pipeline.sx`: `arena_a: Arena;` / `arena_b:
Arena;` (was `*Arena;`). The `build_arena: *Arena` local takes
`@self.arena_a` / `@self.arena_b`.
- `examples/126-xx-recover-then-dispatch.sx`: `recovered == @gpa`
instead of `recovered == gpa` (gpa is a value now).
- `examples/135-xx-lvalue-borrows.sx`: drop the `tracker_ptr.*`
deref — `init` already returns the value.
- `examples/50-smoke.sx`: Arena alloc counts dropped by 1 (no
state-struct allocation). Comments + snapshot updated.
`Arena.deinit` drops the trailing `parent.dealloc(xx a)` — the
caller's local owns the storage.
FFI IR snapshots regenerated to reflect the new signatures:
`@GPA.init` returns `i64` (was `ptr`); `@Arena.init` and
`@TrackingAllocator.init` use sret returns (was `ptr`).
CLAUDE.md "Allocator construction" rule rewritten around the
by-value convention. The forbidden caller-provides-storage and
redundant-pointer-rename patterns are still forbidden but for the
right reasons now (verbose, fragile) rather than as a workaround
for the old `init() -> *T` shape.
157/157 example tests pass; chess clean on macOS, iOS sim, and
Android via `tools/verify-step.sh`.
28 lines
1.1 KiB
Plaintext
28 lines
1.1 KiB
Plaintext
// Option 3 — `xx <lvalue>` borrows the operand's storage instead of
|
|
// heap-copying. The protocol value's `ctx` points directly at the local;
|
|
// mutations through the protocol are visible to the original.
|
|
//
|
|
// The witness is TrackingAllocator: incrementing the parent allocator's
|
|
// counter happens through the Allocator protocol value. If `xx tracker`
|
|
// heap-copied the Tracker, the parent counter would land in the copy
|
|
// and the local would stay at zero. With Option 3 the local sees the
|
|
// increments because they ARE the local.
|
|
#import "modules/std.sx";
|
|
#import "modules/allocators.sx";
|
|
|
|
main :: () -> s32 {
|
|
gpa := GPA.init();
|
|
tracker := TrackingAllocator.init(xx gpa); // value, stack-local
|
|
|
|
// xx tracker — operand is an identifier (lvalue), so the protocol
|
|
// borrows tracker's storage. No heap copy. Mutations propagate.
|
|
push Context.{ allocator = xx tracker, data = null } {
|
|
p := context.allocator.alloc(128);
|
|
context.allocator.dealloc(p);
|
|
}
|
|
|
|
print("alloc_count = {}\n", tracker.alloc_count);
|
|
print("dealloc_count = {}\n", tracker.dealloc_count);
|
|
return 0;
|
|
}
|