Brummel/AILang
1
0
Fork 0
Code Issues 29 Pull Requests Actions Packages Projects Releases Wiki Activity

fix: 18g.2 — let-binder drop for Own-returning App

Browse Source 
18c.3's is_rc_heap_allocated returned false for any Term::App
shape; the doc-comment explicitly deferred the owned-returning-call
case to 'later iters tied to (own) ret-mode contracts'. We have
those contracts (Iter 18a). With this iter the predicate widens to
recognise Term::App whose callee carries ret_mode=Own; the let-
scope close emits a drop call, routing through the per-type drop
fn derived from the call's return type so the cascade walks ptr
children correctly.

Borrow- and Implicit-returning calls are still not trackable —
they don't carry the static caller-owns-the-return signal.

drop_symbol_for_binder gains an App arm that synthesises the
return type and resolves drop_<m>_<T> from it (same shape as the
existing Ctor arm), with cross-module qualification through
import_map. emit_inlined_partial_drop now defaults to shallow
ailang_rc_dec when value is not Term::Ctor — that path is the
dynamic-tag partial-drop debt 18d.4 already documents (the
runtime tag of a let-binder whose value is Term::App is not
statically known, so per-field partial-drop emission is not
usable; closing this remaining leak path requires a tag-
conditional helper, queued as future work).

Red: alloc_rc_let_binder_for_owned_returning_app_drops_at_scope_close
on examples/rc_let_owned_app_leak — pre-fix live=3 (TNode + 2
TLeaf), post-fix live=0.

End-to-end: bench_latency_explicit under --alloc=rc now reports
allocs=11068575 frees=11068575 live=0. The depth-19 Tree cache
+ all 10M per-op IntList cells deallocate cleanly. Decision
10's prompt-deallocation property now holds end-to-end on the
canonical bench fixture.
This commit is contained in:
Brummel
2026-05-08 14:25:07 +02:00
parent 0c09093ef9
commit 88045a485b
4 changed files with 178 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ailang-codegen/src/lib.rs
+87 -15
View File
@@ -1545,12 +1545,17 @@ impl<'a> Emitter<'a> {
/// non-escaping ones become stack `alloca`s and must NOT be
/// `dec`'d (they are freed by LLVM at fn return).
///
/// Other value shapes (calls, vars, literals, matches, …) return
/// `false` here. A call's return value may itself be an
/// RC-allocated box, but the caller does not statically know that
/// — proper handling of returned boxes is part of the wider
/// uniqueness story (and tied to `(own)` ret-mode contracts in
/// later iters).
/// Iter 18g.2 widens this to include `Term::App` whose callee's
/// fn-type carries `ret_mode == Own`. The mode contract states that
/// the callee hands the returned cell's ownership to the caller's
/// frame; the let-scope close is the right place for the caller's
/// dec. Calls whose callee is `Borrow`/`Implicit`-returning are
/// still not trackable — they don't carry that signal.
///
/// Other value shapes (vars, literals, matches, …) return `false`
/// here. A `Term::Var` returning an RC-allocated box would already
/// be tracked by an earlier let-binder; tracking it again here
/// would double-dec.
fn is_rc_heap_allocated(&self, value: &Term) -> bool {
if !matches!(self.alloc, AllocStrategy::Rc) {
return false;
@@ -1560,10 +1565,37 @@ impl<'a> Emitter<'a> {
let term_ptr = (value as *const Term) as usize;
!self.non_escape.contains(&term_ptr)
}
Term::App { callee, .. } => {
// Iter 18g.2: a call whose callee carries
// `ret_mode == Own` hands a fresh heap allocation to
// the caller's frame. Trackable. `Borrow` and
// `Implicit` ret-modes do not carry that signal —
// returning by Borrow is a view into the callee's
// owned data (caller does not own it), and Implicit
// is the back-compat lane that 18c.3's debt covers.
self.synth_callee_ret_mode(callee)
.map(|m| matches!(m, ParamMode::Own))
.unwrap_or(false)
}
_ => false,
}
}
/// Iter 18g.2: lookup helper for a callee's `ret_mode`. Returns
/// `Some(mode)` when the callee resolves to a fn-typed term;
/// `None` for shapes whose type is not a `Type::Fn` (typechecker
/// would already have rejected an App on a non-fn, but the helper
/// is defensive). Used by [`Self::is_rc_heap_allocated`] and the
/// [`Self::drop_symbol_for_binder`] App-arm to decide both
/// trackability and the drop-fn symbol.
fn synth_callee_ret_mode(&self, callee: &Term) -> Option<ParamMode> {
let cty = self.synth_arg_type(callee).ok()?;
match cty {
Type::Fn { ret_mode, .. } => Some(ret_mode),
_ => None,
}
}
/// Iter 18c.4: pick the drop-fn symbol to call at the close of a
/// trackable `Term::Let` scope. For a `Term::Ctor` binder the
/// symbol is `drop_<owner>_<TypeName>` — derived from the ctor's
@@ -1594,6 +1626,31 @@ impl<'a> Emitter<'a> {
.get(val_ssa)
.cloned()
.unwrap_or_else(|| "ailang_rc_dec".to_string()),
// Iter 18g.2: an Own-returning call hands a freshly heap-
// allocated cell whose static type is the callee's
// `ret`. Resolve the per-type drop fn from that ret-type
// so the cascade walks the cell's pointer-typed children
// (e.g. an Own-returned `Tree` fans out via
// `drop_<m>_<Tree>`). Falls back to `ailang_rc_dec` if
// the ret-type is not a `Type::Con` (e.g. a bare type
// var on an as-yet-unmonomorphised polymorphic call —
// the monomorphised copies will resolve correctly).
Term::App { .. } => {
if let Ok(ret_ty) = self.synth_arg_type(value) {
if let Type::Con { name, .. } = ret_ty {
if name.matches('.').count() == 1 {
let (prefix, suffix) =
name.split_once('.').expect("checked");
if let Some(target) = self.import_map.get(prefix) {
return format!("drop_{target}_{suffix}");
}
return format!("drop_{prefix}_{suffix}");
}
return format!("drop_{m}_{name}", m = self.module_name);
}
}
"ailang_rc_dec".to_string()
}
_ => "ailang_rc_dec".to_string(),
}
}
@@ -1608,11 +1665,15 @@ impl<'a> Emitter<'a> {
/// transferred to a pattern-bound binder that owns the dec
/// for them.
///
/// `value` must be a `Term::Ctor` — `is_rc_heap_allocated` only
/// returns true for `Term::Ctor` / `Term::Lam`, and a `Term::Lam`
/// binder cannot accumulate moved slots (closures are not pattern-
/// matched into positional fields). The match-or-error pattern
/// guards that invariant.
/// Iter 18g.2 widens the input set: with `Term::App` (Own-
/// returning call) now also trackable, a let-binder whose value is
/// `Term::App` may accumulate moved slots if its body pattern-
/// matches the binder. The per-field static-ctor emission below
/// is not usable in that case (the runtime tag is dynamic, not
/// statically known from `value`'s shape); fall back to shallow
/// `ailang_rc_dec`. The non-moved field cells leak under that
/// path — same dynamic-tag partial-drop debt that 18d.4's match
/// arm already documents.
fn emit_inlined_partial_drop(
&mut self,
value: &Term,
@@ -1622,11 +1683,22 @@ impl<'a> Emitter<'a> {
let (type_name, ctor_name) = match value {
Term::Ctor { type_name, ctor, .. } => (type_name.as_str(), ctor.as_str()),
_ => {
return Err(CodegenError::Internal(
"emit_inlined_partial_drop: binder value is not a Term::Ctor; \
moved_slots should only accumulate against Ctor binders"
.into(),
// Iter 18g.2 fallback: dynamic-tag partial-drop debt.
// `value` is `Term::App` (Own-returning) or `Term::Lam`
// — `is_rc_heap_allocated` returns true for both, and a
// body that pattern-matches such a binder will populate
// `moved_slots`. We don't know the active ctor
// statically, so we shallow-dec the outer cell. Non-
// moved field cells leak under this path; closing the
// leak requires a tag-conditional partial-drop helper
// (analogous to the per-type drop fn but parameterised
// on the tag). Tracked as future work — same family as
// 18d.4's `(case (LCons h t) ...)` carve-out.
let _ = (val_ssa, moved); // keep compiler quiet about unused
self.body.push_str(&format!(
" call void @ailang_rc_dec(ptr {val_ssa})\n"
));
return Ok(());
}
};
let cref = self.lookup_ctor_by_type(type_name, ctor_name)?;