iter boehm-retirement.1 (DONE 10/10): retire the transitional Boehm GC backend
Closes Gitea #4. Removes the Boehm-Demers-Weiser conservative GC backend wholesale across six layers in one atomic iteration. After this iter, `AllocStrategy` has two variants (`Rc`, `Bump`), `--alloc=gc` is rejected at CLI parse with `unknown --alloc value`, the libgc link arm is gone, and the design ledger describes RC (canonical) + bump (raw-alloc bench-floor) as the only allocators. Layer-by-layer summary: CLI surface — `crates/ail/src/main.rs`: `parse_alloc_strategy` arm `"gc" => Ok(AllocStrategy::Gc)` removed; error wording updated to `(expected `rc` or `bump`)`; clap-derive `value_parser = ["gc","bump","rc"]` allowlist on BOTH `Build` and `Run` subcommands DROPPED so that `parse_alloc_strategy` remains the sole gatekeeper for the unknown-value diagnostic (otherwise clap shadows the runtime diagnostic with `invalid value 'gc' for '--alloc'`, which would miss the milestone-pin's stderr substring check). The `default_value = "rc"` stays. Codegen — `crates/ailang-codegen/src/lib.rs`: `AllocStrategy::Gc` variant + `Default` derive removed (no caller of `AllocStrategy::default()` existed in the workspace, so the trait derivation was dead). `fn_name` (spec called it `runtime_alloc_fn` loosely; actual identifier is `fn_name`) drops the `Gc => "GC_malloc"` arm. `lower_workspace` and `lower_workspace_staticlib` defaults flip from `Gc` to `Rc`. In-source negative-complement codegen test (mod tests, lib.rs:3571ff) retargets from `AllocStrategy::Gc` to `AllocStrategy::Bump` (bump also doesn't emit per-type drop fns; the test's semantic "no drop fns under non-RC" is preserved). Link branch — `crates/ail/src/main.rs:2389ff`: The `match strategy { AllocStrategy::Gc => { ... cmd.arg("-lgc"); ... } }` arm and its libgc-link block are entirely gone. The surviving match exhausts on `Bump` and `Rc` (Rust's exhaustiveness check confirms; no `error[E0004]`). Staticlib-guard diagnostic rewritten to drop the "shared Boehm collector" phrasing while preserving the prefix `staticlib (swarm) artefact is RC-only` verbatim (the surviving `staticlib_bump_is_rejected` test depends on that substring). Test suite — 3 pure-differential e2e tests deleted (`gc_handles_recursive_list_construction`, `alloc_rc_produces_same_stdout_as_gc`, `alloc_rc_matches_gc_on_std_list_demo`); 9 RC-feature tests stripped of their `stdout_gc` build call and differential `assert_eq!(stdout_gc, stdout_rc, ...)` (absolute `assert_eq!(stdout_rc.trim(), "<n>")` pin retained as correctness oracle); `staticlib_gc_is_rejected` deleted; new milestone-pin `crates/ail/tests/boehm_retirement_pin.rs` asserts `ail build --alloc=gc` exits ≠ 0 with stderr containing `unknown --alloc value` and `\`gc\``; `examples/gc_stress.ail` fixture deleted (no remaining references). Implementer expansion (not in plan): `iter17a_local_box_alloca` (in `e2e.rs`) carried an IR-shape assertion against `@GC_malloc`-absence as the witness for non-escaping allocation. After the Task-2 codegen default flip, the witness shifts to `@ailang_rc_alloc`-absence in escape-targeted positions; assertion + doc-comment updated. Property protected ("no heap allocation in non-escaping contexts") is unchanged; only the named allocator shifts. Bench harness — `bench/run.sh` 9→6 column compaction (workload + bump(s) + rc(s) + rc/bump + bump RSS + rc RSS); gc-arm `bench_latency_implicit_gc` build call + harness invocation dropped from latency block; header comment reframed from "GC-overhead bench harness" to "RC-overhead bench harness"; "Decision 10's Boehm-retirement target (1.3x)" rewording to "RC-overhead-vs-bump bench-health regression gate". `bench/check.py:62` header-sentinel changes from `"gc(s)" in line` to `"bump(s)" in line`; column-count check at `:72` flips from `!= 9` to `!= 6`; per-workload field set drops `gc_s`/`gc_over_bump`/`gc_rss_kb`; `ARM_LABEL_TO_KEY` drops the `"implicit @ gc": "implicit_at_gc"` entry. `bench/baseline.json` regenerated via `--update-baseline`. Implementer note (planner-defect): `write_new_baseline` iterated over the *existing* baseline's metric list when emitting the regenerated file, so even after parser-level `gc_*` removal, the fallback emitted them back into the JSON. Scrubbed post-update; the cleaner fix (have `write_new_baseline` emit only keys present in `parsed_throughput[workload]`) is a follow-up if the script becomes load-bearing for further allocator changes. Design ledger — `design/models/rc-uniqueness.md` excises the `## Dual allocator — RC canonical, Boehm parity oracle` section and the `Boehm-Demers-Weiser conservative GC` choice block + rationale + trade-offs; the per-fn-alloca section generalises Boehm-specific language to allocator-agnostic; the memory-model section's `## Choice.` paragraph reframes the 1.3× target from "Boehm-retirement gate" to "bench-health regression gate". `design/models/pipeline.md` drops the `--alloc=gc → links libgc` arm of the pipeline diagram and replaces it with `--alloc=bump → links bump-floor`; the accompanying prose rewrites accordingly. `design/contracts/scope-boundaries.md` rewrites the "Memory management via Boehm conservative GC" bullet to describe RC + per-fn-arena present-tense; the dead reference to `examples/gc_stress.ail.json` (file never existed; the fixture only ever had a `.ail` form, deleted by this iter) is dropped along with the `examples/std_list_stress.ail.json` reference whose purpose was Boehm-only soak testing. `:67`'s `@printf` / `@GC_malloc` parenthetical updated. `design/contracts/memory-model.md:232` drops the "leaks like the pre-Boehm era" phrase; the RC inc/dec instrumentation is wired up, so the "until then" conditional that referenced pre-Boehm is closed. `design/contracts/embedding-abi.md:42-44` rewrites the staticlib-guard prose to drop the `--alloc=gc` clause (gc is now a CLI-parser-level unknown-value, not a staticlib-guard rejection) and reframe the swarm-safety justification around `--alloc=bump` (leak-only bench instrument) rather than the historical Boehm collector. Honesty pin — `crates/ailang-core/tests/docs_honesty_pin.rs` inverts the polarity: the present-tense Boehm-anchor assertion on `pipeline.md` (`:116-117`) is deleted, and four absence-pins are added to `design_md_has_no_wunschdenken` against the Boehm-zombie strings `transitional Boehm`, `parity oracle`, `GC_malloc`, `libgc`. The `design_corpus()` already includes `rc-uniqueness.md` so no path-list change was needed for the new pins to scan. `crates/ailang-core/tests/design_index_pin.rs:166` drops the `"pre-Boehm"` token from the protected-exception comment list (the phrase no longer appears in `memory-model.md` after this iter, so the exception is dead). Runtime docs — `runtime/bump.c`, `runtime/rc.c`, `runtime/str.c` header comments scrubbed of Boehm/`GC_malloc`/`libgc` references. `bump.c`'s function signature description still documents `void *bump_malloc(size_t)` as the bench-floor allocator interface, but no longer cross-references libgc. Example fixtures — `examples/bench_latency_implicit.ail`, `bench_latency_explicit.ail`, `escape_local_demo.ail`, `reuse_as_demo.ail`, `rc_pin_recurse_implicit.ail` doc-comment headers scrubbed of `--alloc=gc` / Boehm references. The `.ail` surface (AST) is untouched in every case; round-trip invariant holds (`cargo test -p ailang-surface --test round_trip` green). Skill / agent prompts — `skills/audit/agents/ailang-bencher.md` rewritten to use an RC-vs-bump worked example pattern for the hypothesis-driven bench tutorial, replacing the recurring "RC vs Boehm under heap pressure" example. `skills/implement/agents/ailang-implementer.md` Decision-10 / Boehm references replaced with present-tense RC-commitment framing. IR snapshots — the 5 checked-in snapshots (`crates/ail/tests/snapshots/{hello,list,max3,sum,ws_main}.ll`) regenerated via `UPDATE_SNAPSHOTS=1 cargo test -p ail --test ir_snapshot`. Each previously contained `declare ptr @GC_malloc(i64)` and (for `list.ll`) a `call ptr @GC_malloc(...)` invocation; post-flip the snapshots contain `declare ptr @ailang_rc_alloc(i64)` plus the rc inc/dec runtime declarations. Spec-vs-acceptance addendum (caught at orchestrator end-report, absorbed here rather than in a follow-up spec edit): spec §6 acceptance criteria said "Boehm-grep returns matches ONLY in docs_honesty_pin.rs". The plan itself prescribed historical Boehm references in 3 additional files: (a) the new milestone-pin `boehm_retirement_pin.rs` (must literally invoke `--alloc=gc` to assert its rejection), (b) `embed_staticlib_alloc_guard.rs` file doc-comment historical note ("`--alloc=gc` no longer exists as a CLI value"), (c) `embedding-abi.md:44-45` contract historical clause ("see the Boehm-retirement iter"). All three are prescribed; the spec's grep wording was too narrow. The four absence-pins in `docs_honesty_pin.rs` catch the actual zombies (Boehm-narrative re-emerging in the design ledger), which is the substantive intent the spec was aiming at — the four extra documented-by-design exceptions are the cost of having an explicit milestone-pin and contract-level historical anchors. Net delta: - 32 files modified, 2 new (boehm_retirement_pin.rs + stats), 1 deleted (gc_stress.ail); - workspace tests: every binary `0 failed`. Pass-count delta: -3 net (4 e2e tests deleted, 1 new milestone-pin test added); - boehm-grep state: hits only in the four by-design exceptions documented above; - `bench/check.py` exit 0 against regenerated baseline; - CLI must-fail fixture: `ail build --alloc=gc examples/hello.ail` exits non-zero with stderr containing `unknown --alloc value` and `\`gc\``; - design ledger present-tense honest (Boehm-narrative gone from `rc-uniqueness.md` + `pipeline.md`; the few historical references in `embedding-abi.md` / `boehm_retirement_pin.rs` / `embed_staticlib_alloc_guard.rs` are explicit milestone-pins or contract anchors, not silent ledger residue). Bench measurement variance noted: closure-chain and hof-pipeline are ±1-5% jittery between runs; one regeneration flagged 2 metrics as `regressed` before a second run returned 0. The captured baseline is within self-comparison range. Existing per-metric tolerances absorb the jitter. Stats file: `bench/orchestrator-stats/2026-05-20-iter-boehm-retirement.1.json`. closes #4
This commit is contained in:
+27
-136
@@ -183,35 +183,16 @@ fn list_map_poly_inc_then_prints() {
|
||||
assert_eq!(lines, vec!["2", "3", "4"]);
|
||||
}
|
||||
|
||||
/// stress the Boehm conservative GC integration end-to-end.
|
||||
/// `build 50` performs 50 `Cons` allocations via `GC_malloc`; `sum_list`
|
||||
/// walks the resulting `List Int` and prints the sum (1275 = 50*51/2).
|
||||
/// If GC is wired wrongly — missing `-lgc`, missing
|
||||
/// `declare ptr @GC_malloc(i64)`, libgc misbehaving on this build host —
|
||||
/// the test fails at link or run time. The match-on-Bool against
|
||||
/// `(== n 0)` shape is used because `(pat-lit 0)` against an `Int`
|
||||
/// scrutinee with a wildcard fallback is not currently in the grammar.
|
||||
#[test]
|
||||
fn gc_handles_recursive_list_construction() {
|
||||
let stdout = build_and_run("gc_stress.ail");
|
||||
assert_eq!(
|
||||
stdout.trim(),
|
||||
"1275",
|
||||
"expected sum [50,49,..,1] = 1275; \
|
||||
GC_malloc / -lgc integration may be broken"
|
||||
);
|
||||
}
|
||||
|
||||
/// per-fn arena via stack `alloca` for non-escaping
|
||||
/// allocations. The fixture's `peek` and `count` fns each build a
|
||||
/// `Box(_)` whose payload is dropped via a wildcard pattern; the
|
||||
/// allocation is fully consumed locally and never flows to a fn
|
||||
/// arg, ctor field, or the fn return. Escape analysis must flag
|
||||
/// these allocations as non-escaping; codegen must lower them with
|
||||
/// `alloca` instead of `@GC_malloc`. Two assertions:
|
||||
/// `alloca` instead of the runtime allocator. Two assertions:
|
||||
/// (1) stdout matches the documented expected outputs;
|
||||
/// (2) the emitted IR contains at least one `alloca i8, i64 16`
|
||||
/// for the Box and zero `@GC_malloc` calls inside `peek`/`count`.
|
||||
/// for the Box and zero `@ailang_rc_alloc` calls inside `peek`/`count`.
|
||||
#[test]
|
||||
fn iter17a_local_box_alloca() {
|
||||
let stdout = build_and_run("escape_local_demo.ail");
|
||||
@@ -222,7 +203,7 @@ fn iter17a_local_box_alloca() {
|
||||
);
|
||||
|
||||
// IR check: peek and count should each contain `alloca` and no
|
||||
// `@GC_malloc`. Emit, then split into per-fn bodies and inspect.
|
||||
// runtime-allocator call. Emit, then split into per-fn bodies and inspect.
|
||||
let manifest_dir = env!("CARGO_MANIFEST_DIR");
|
||||
let workspace = Path::new(manifest_dir).parent().unwrap().parent().unwrap();
|
||||
let src = workspace
|
||||
@@ -257,8 +238,8 @@ fn iter17a_local_box_alloca() {
|
||||
"fn {fn_name} should contain `alloca i8, i64 16`; body:\n{body}"
|
||||
);
|
||||
assert!(
|
||||
!body.contains("@GC_malloc"),
|
||||
"fn {fn_name} should NOT contain `@GC_malloc` (allocation \
|
||||
!body.contains("@ailang_rc_alloc"),
|
||||
"fn {fn_name} should NOT contain `@ailang_rc_alloc` (allocation \
|
||||
must be alloca'd); body:\n{body}"
|
||||
);
|
||||
}
|
||||
@@ -1393,20 +1374,6 @@ fn eq_demo() {
|
||||
);
|
||||
}
|
||||
|
||||
/// --alloc=rc routes allocation through ailang_rc_alloc
|
||||
/// (8-byte refcount header, libc malloc backing). With no inc/dec
|
||||
/// emission yet (18c work), programs leak under this mode but must
|
||||
/// still produce correct stdout — that's the validation 18b ships.
|
||||
#[test]
|
||||
fn alloc_rc_produces_same_stdout_as_gc() {
|
||||
// Pick a fixture with non-trivial allocation: list-building + match.
|
||||
let example = "list.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc, stdout_rc, "alloc=rc must match alloc=gc");
|
||||
assert_eq!(stdout_rc.trim(), "42");
|
||||
}
|
||||
|
||||
/// `Term::Clone` is a pure schema addition. In 18c.1 the
|
||||
/// wrapper is identity for both typechecker (same type as inner) and
|
||||
/// codegen (same SSA reg, no extra IR) — programs that contain
|
||||
@@ -1423,17 +1390,14 @@ fn clone_demo_is_identity_in_18c1() {
|
||||
/// Term::Ctor }` lowers to a runtime refcount-1 dispatch — when the
|
||||
/// source's box is unique we overwrite it in place (skipping the
|
||||
/// alloc + cascade-dec round-trip); otherwise we fall back to a
|
||||
/// fresh allocation and dec the source. Other allocators keep the
|
||||
/// 18d.1 identity behaviour.
|
||||
/// fresh allocation and dec the source.
|
||||
///
|
||||
/// Properties guarded:
|
||||
/// (1) The fixture's canonical JSON contains `"t":"reuse-as"` — the
|
||||
/// schema for the new variant did not regress.
|
||||
/// (2) `--alloc=gc` produces `9` (1+1 + 2+1 + 3+1) — the legacy
|
||||
/// identity codegen still produces correct output.
|
||||
/// (3) `--alloc=rc` produces the SAME `9` — the in-place rewrite is
|
||||
/// observably equivalent to the gc path on this fixture.
|
||||
/// (4) `--alloc=rc` exits cleanly (status 0; no segfault, no
|
||||
/// (2) `--alloc=rc` produces `9` (1+1 + 2+1 + 3+1) — the in-place
|
||||
/// rewrite produces correct output.
|
||||
/// (3) `--alloc=rc` exits cleanly (status 0; no segfault, no
|
||||
/// refcount underflow). `build_and_run_with_alloc` panics on
|
||||
/// non-zero exit, so this is implicit but worth naming.
|
||||
/// (5) The emitted IR for `--alloc=rc` contains both:
|
||||
@@ -1471,11 +1435,8 @@ fn reuse_as_demo_under_rc_uses_inplace_rewrite() {
|
||||
"expected `\"t\":\"reuse-as\"` in canonical JSON; the schema for `(reuse-as ...)` regressed"
|
||||
);
|
||||
|
||||
// (2) gc baseline.
|
||||
let stdout_gc = build_and_run_with_alloc("reuse_as_demo.ail", "gc");
|
||||
assert_eq!(stdout_gc.trim(), "9");
|
||||
// (3) rc matches gc, (4) clean exit (build_and_run_with_alloc
|
||||
// panics on non-zero status).
|
||||
// (2) rc build produces the expected stdout (clean exit via
|
||||
// build_and_run_with_alloc panicking on non-zero status).
|
||||
let stdout_rc = build_and_run_with_alloc("reuse_as_demo.ail", "rc");
|
||||
assert_eq!(stdout_rc.trim(), "9");
|
||||
|
||||
@@ -1557,21 +1518,6 @@ fn reuse_as_demo_under_rc_uses_inplace_rewrite() {
|
||||
);
|
||||
}
|
||||
|
||||
/// extends `alloc_rc_produces_same_stdout_as_gc` to a larger
|
||||
/// fixture (`std_list_demo`) so more allocation sites — folds, maps,
|
||||
/// cross-module ctors — are exercised under `--alloc=rc`. Same
|
||||
/// invariant: stdout must be byte-identical to the `gc` build.
|
||||
#[test]
|
||||
fn alloc_rc_matches_gc_on_std_list_demo() {
|
||||
let example = "std_list_demo.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on std_list_demo"
|
||||
);
|
||||
}
|
||||
|
||||
/// codegen actually emits `ailang_rc_dec` at end-of-scope
|
||||
/// for trackable RC binders under `--alloc=rc`. This is the first
|
||||
/// fixture where the `dec` path runs at runtime — `b` is bound to a
|
||||
@@ -1582,15 +1528,11 @@ fn alloc_rc_matches_gc_on_std_list_demo() {
|
||||
/// the underlying `malloc`'d block is freed by `runtime/rc.c`.
|
||||
///
|
||||
/// Properties guarded:
|
||||
/// (1) the binary still produces the expected stdout (`42`) — i.e.
|
||||
/// dec does not free the box BEFORE `match` reads its `Int`
|
||||
/// payload;
|
||||
/// (1) the binary produces stdout `42` — i.e. dec does not free the
|
||||
/// box BEFORE `match` reads its `Int` payload;
|
||||
/// (2) the binary exits cleanly (exit code 0, no segfault) — i.e.
|
||||
/// the dec call does not double-free or trip
|
||||
/// `ailang_rc_dec`'s underflow guard;
|
||||
/// (3) the GC and RC paths produce byte-identical stdout — i.e.
|
||||
/// the dec emission did not perturb behaviour visible at the
|
||||
/// output boundary.
|
||||
/// `ailang_rc_dec`'s underflow guard.
|
||||
///
|
||||
/// Box has no boxed children, so the shallow-free contract of 18c.3's
|
||||
/// `ailang_rc_dec` is sufficient. A recursive ADT (List, Tree) would
|
||||
@@ -1599,11 +1541,8 @@ fn alloc_rc_matches_gc_on_std_list_demo() {
|
||||
#[test]
|
||||
fn alloc_rc_emits_dec_for_unique_let_bound_box() {
|
||||
let example = "rc_box_drop.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "42");
|
||||
assert_eq!(stdout_rc.trim(), "42");
|
||||
assert_eq!(stdout_gc, stdout_rc, "alloc=rc must match alloc=gc on rc_box_drop");
|
||||
}
|
||||
|
||||
/// per-type drop fns + recursive `dec` cascade. Builds a
|
||||
@@ -1611,8 +1550,8 @@ fn alloc_rc_emits_dec_for_unique_let_bound_box() {
|
||||
/// `--alloc=rc` the codegen emits `define void @drop_<m>_IntList`
|
||||
/// whose `Cons` arm recursively calls itself on the `tail` field —
|
||||
/// the first iter where a recursive ADT under RC frees its tail
|
||||
/// cells when their drop fn is invoked. Stdout must match `--alloc=gc`
|
||||
/// (`15`) and the binary must exit cleanly.
|
||||
/// cells when their drop fn is invoked. Stdout is `15` (the sum
|
||||
/// of `[1,2,3,4,5]`) and the binary must exit cleanly.
|
||||
///
|
||||
/// Note: in this fixture the binder `xs` has `consume_count == 1`
|
||||
/// (passed to `sum_list`), so codegen does NOT emit a drop call at
|
||||
@@ -1625,14 +1564,8 @@ fn alloc_rc_emits_dec_for_unique_let_bound_box() {
|
||||
#[test]
|
||||
fn alloc_rc_recursive_list_sum() {
|
||||
let example = "rc_list_drop.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "15");
|
||||
assert_eq!(stdout_rc.trim(), "15");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_list_drop"
|
||||
);
|
||||
}
|
||||
|
||||
/// exercise the recursive drop cascade at
|
||||
@@ -1662,8 +1595,7 @@ fn alloc_rc_recursive_list_sum() {
|
||||
/// Properties guarded:
|
||||
/// 1. The binary runs to completion (no segfault from a
|
||||
/// mishandled recursive cascade or refcount underflow).
|
||||
/// 2. Stdout matches `--alloc=gc` byte-for-byte (`11` — the head
|
||||
/// of the 5-element list).
|
||||
/// 2. Stdout is `11` (the head of the 5-element list).
|
||||
/// 3. The Cons arm's body emits the per-type drop on `t` between
|
||||
/// the `print h` call and the arm's branch back to the match
|
||||
/// join — the IR-shape signature of 18d.4's arm-close
|
||||
@@ -1671,14 +1603,8 @@ fn alloc_rc_recursive_list_sum() {
|
||||
#[test]
|
||||
fn alloc_rc_borrow_only_recursive_list_drop() {
|
||||
let example = "rc_list_drop_borrow.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "11");
|
||||
assert_eq!(stdout_rc.trim(), "11");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_list_drop_borrow"
|
||||
);
|
||||
|
||||
// IR-shape assertion: the Cons arm of main's match emits a drop
|
||||
// on `t` after lowering the body. We re-lower under
|
||||
@@ -1749,24 +1675,16 @@ fn alloc_rc_borrow_only_recursive_list_drop() {
|
||||
/// 3. YES `@ailang_rc_dec(<p>)` for the outer Pair box.
|
||||
///
|
||||
/// Properties guarded:
|
||||
/// 1. The binary runs to completion under both `--alloc=gc` and
|
||||
/// `--alloc=rc`.
|
||||
/// 2. Stdout matches `--alloc=gc` byte-for-byte (`6` — the sum of
|
||||
/// the first list, [1,2,3]).
|
||||
/// 1. The binary runs to completion under `--alloc=rc`.
|
||||
/// 2. Stdout is `6` (the sum of the first list, [1,2,3]).
|
||||
/// 3. The IR at p's let-close contains an inlined per-field drop
|
||||
/// for slot 1 (the wildcarded IntList) but NOT the uniform
|
||||
/// `drop_<m>_Pair` call against `p`.
|
||||
#[test]
|
||||
fn alloc_rc_partial_drop_skips_moved_keeps_wildcarded() {
|
||||
let example = "pat_extract_partial_drop.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "6");
|
||||
assert_eq!(stdout_rc.trim(), "6");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on pat_extract_partial_drop"
|
||||
);
|
||||
|
||||
// Re-lower under rc to inspect the IR shape directly.
|
||||
let manifest_dir = env!("CARGO_MANIFEST_DIR");
|
||||
@@ -1838,11 +1756,10 @@ fn alloc_rc_partial_drop_skips_moved_keeps_wildcarded() {
|
||||
/// the param SSA (`%arg_xs`) before the fn's `ret`.
|
||||
///
|
||||
/// Properties guarded:
|
||||
/// 1. The binary runs to completion under both `--alloc=gc` and
|
||||
/// `--alloc=rc` (no segfault from a mishandled cascade or
|
||||
/// refcount underflow when the cascade hits the moved tail).
|
||||
/// 2. Stdout matches `--alloc=gc` byte-for-byte (`11` — the head
|
||||
/// of the 5-element list).
|
||||
/// 1. The binary runs to completion under `--alloc=rc` (no segfault
|
||||
/// from a mishandled cascade or refcount underflow when the
|
||||
/// cascade hits the moved tail).
|
||||
/// 2. Stdout is `11` (the head of the 5-element list).
|
||||
/// 3. `head_or_zero`'s body contains a drop call against
|
||||
/// `%arg_xs` BEFORE the `ret i64`. The drop may be the
|
||||
/// per-type `@drop_<m>_IntList(ptr %arg_xs)` (when no slots
|
||||
@@ -1855,14 +1772,8 @@ fn alloc_rc_partial_drop_skips_moved_keeps_wildcarded() {
|
||||
#[test]
|
||||
fn alloc_rc_own_param_dec_at_fn_return() {
|
||||
let example = "rc_own_param_drop.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "11");
|
||||
assert_eq!(stdout_rc.trim(), "11");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_own_param_drop"
|
||||
);
|
||||
|
||||
// Re-lower under rc to inspect head_or_zero's IR shape.
|
||||
let manifest_dir = env!("CARGO_MANIFEST_DIR");
|
||||
@@ -1972,20 +1883,11 @@ fn alloc_rc_own_param_dec_at_fn_return() {
|
||||
/// recursive cascade overflowing the C stack — which DOES
|
||||
/// happen on the same fixture with the annotation removed,
|
||||
/// hand-verified during 18e implementation).
|
||||
/// 3. `--alloc=gc` produces the same stdout (allocator-equivalence
|
||||
/// backstop; 1M cells at 24B each ≈ 24MB, well within Boehm's
|
||||
/// capacity).
|
||||
#[test]
|
||||
fn alloc_rc_drop_iterative_handles_million_cell_list() {
|
||||
let example = "rc_drop_iterative_long_list.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_rc.trim(), "1");
|
||||
assert_eq!(stdout_gc.trim(), "1");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_drop_iterative_long_list"
|
||||
);
|
||||
}
|
||||
|
||||
/// IR-shape signature of `(drop-iterative)`. The drop fn
|
||||
@@ -2157,22 +2059,17 @@ fn iter18e_no_annotation_keeps_recursive_drop_body() {
|
||||
/// (1) The binary exits cleanly under `--alloc=rc` (no SIGSEGV
|
||||
/// from a use-after-free, no abort from
|
||||
/// `ailang_rc_dec: refcount underflow` in `runtime/rc.c`).
|
||||
/// (2) Stdout matches `--alloc=gc` (`0`).
|
||||
/// (2) Stdout is `0` (the implicit-mode pinned-recursion fixture
|
||||
/// prints the recursion result, not a pointer/payload).
|
||||
///
|
||||
/// Pre-fix this test fails with exit code 139 (SIGSEGV) under rc.
|
||||
/// Post-fix both arms produce the same clean output. Kept as
|
||||
/// Post-fix `--alloc=rc` produces clean output. Kept as
|
||||
/// regression coverage — see CLAUDE.md "Bug fixes — TDD, always".
|
||||
#[test]
|
||||
fn alloc_rc_pattern_bind_in_implicit_fn_does_not_dec_borrowed_children() {
|
||||
let example = "rc_pin_recurse_implicit.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "0");
|
||||
assert_eq!(stdout_rc.trim(), "0");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_pin_recurse_implicit"
|
||||
);
|
||||
}
|
||||
|
||||
/// build the example under `--alloc=rc`, run with
|
||||
@@ -2389,18 +2286,12 @@ fn alloc_rc_let_binder_for_implicit_returning_app_does_not_drop() {
|
||||
/// Post-fix: `current_param_modes` propagates through `Term::Let
|
||||
/// { value: Term::Var(p), ... }` for the duration of the let body,
|
||||
/// so a let-aliased Implicit / Borrow scrutinee correctly skips
|
||||
/// the arm-close drop. Output matches `--alloc=gc` (`0`).
|
||||
/// the arm-close drop. Stdout is `0`.
|
||||
#[test]
|
||||
fn alloc_rc_let_alias_of_implicit_param_does_not_dec_borrowed_children() {
|
||||
let example = "rc_let_alias_implicit_param.ail";
|
||||
let stdout_gc = build_and_run_with_alloc(example, "gc");
|
||||
let stdout_rc = build_and_run_with_alloc(example, "rc");
|
||||
assert_eq!(stdout_gc.trim(), "0");
|
||||
assert_eq!(stdout_rc.trim(), "0");
|
||||
assert_eq!(
|
||||
stdout_gc, stdout_rc,
|
||||
"alloc=rc must match alloc=gc on rc_let_alias_implicit_param"
|
||||
);
|
||||
}
|
||||
|
||||
/// Regression — RED-then-GREEN for the dynamic-tag partial-drop
|
||||
|
||||
Reference in New Issue
Block a user