184c054 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

184c054 — Peter John 2026-11-03T16:59:10+05:30

Tail calls: self tail calls as loops, return_call, tail modulo cons; break depth fix

Files changed (13) hide show

plum-cli/src/main.rs +6 -1
plum-core/src/ast.rs +15 -0
plum-core/src/lib.rs +2 -0
plum-core/src/tail.rs +265 -0
plum-core/src/trmc.rs +446 -0
plum-core/tests/tail_test.rs +134 -0
plum-core/tests/trmc_test.rs +287 -0
plum-examples/tail_calls.plum +90 -0
plum-game/src/host.rs +3 -1
plum-game/web-test/fixtures/stress_state_view_deep.plum +202 -0
plum-runtime/src/main.rs +3 -1
plum-wasm-codegen/src/lib.rs +186 -158
plum-wasm-codegen/tests/tail_calls_e2e_test.rs +283 -0

plum-cli/src/main.rs CHANGED Viewed

@@ -794,9 +794,11 @@ fn cmdRun(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()>
     // GC + typed function references are required to load modules containing
     // Plum's structs/enums/strings/closures (see docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).
     let mut config = wasmtime::Config::new();
-    config.wasm_tail_call(true);
     config.wasm_gc(true);
     config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    config.max_wasm_stack(4 << 20);
+    config.async_stack_size(8 << 20);
     let engine = wasmtime::Engine::new(&config)
         .map_err(|e| anyhow::anyhow!("failed to construct wasmtime engine: {e}"))?;
@@ -947,6 +949,9 @@ fn runTestFile(file: &std::path::Path, lib_path: &std::path::Path) -> Result<(us
     let mut config = wasmtime::Config::new();
     config.wasm_gc(true);
     config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    config.max_wasm_stack(4 << 20);
+    config.async_stack_size(8 << 20);
     let engine = wasmtime::Engine::new(&config)
         .map_err(|e| anyhow::anyhow!("failed to construct wasmtime engine: {e}"))?;

plum-core/src/ast.rs CHANGED Viewed

@@ -724,6 +724,21 @@ pub struct FnCall {
     /// `obj.name(...)`), for diagnostics. `(0, 0)` for a synthetic call.
     pub line: usize,
     pub column: usize,
+    /// Set by `tail::markTailCalls`: whether (and how) this call is in tail position.
+    pub tail: TailKind,
+}
+/// How a call in tail position is made (see `tail.rs`). `NotTail` is the default.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum TailKind {
+    #[default]
+    NotTail,
+    /// A call to the enclosing fn itself (`self.f(..)` for a method).
+    SelfCall,
+    /// A tail call to another fn or method.
+    Other,
+    /// A tail call of a closure value held in a local or parameter.
+    Closure,
 }
 #[derive(Debug, Clone, PartialEq)]

plum-core/src/lib.rs CHANGED Viewed

@@ -10,7 +10,9 @@ pub mod formatter;
 pub mod forms;
 pub mod loader;
 pub mod parser;
+pub mod tail;
 pub mod traits;
+pub mod trmc;
 pub mod union_lower;
 pub mod unions;

plum-core/src/tail.rs ADDED Viewed

@@ -0,0 +1,265 @@
+//! Marks calls in tail position (`FnCall::tail`). Runs on the fully lowered
+//! program, just before codegen.
+//!
+//! Tail position: the value of a fn body, the last expression of a block in tail
+//! position, each `if`/`match`/inline-`if` arm in tail position, and `return e`.
+//! Not tail: under `try`/`!`/`catch`, as an argument or operand, under a loop,
+//! inside a `test` (desugared `__test_N` fns), or in an `export fn`. A call inside
+//! a closure body is tail relative to the closure only.
+use crate::ast::*;
+use std::collections::HashSet;
+#[derive(Debug, Clone, PartialEq)]
+pub struct TailSite {
+    pub callee: String,
+    pub kind: TailKind,
+    pub line: usize,
+}
+/// Marks every tail call of every fn in `src`.
+pub fn markTailCalls(src: &mut Source) {
+    for item in &mut src.items {
+        if let Item::Fn(f) = item {
+            markFn(f);
+        }
+    }
+}
+/// The tail calls of `f` (as `markTailCalls` would mark them), in source order.
+pub fn tailCalls(f: &Fn) -> Vec<TailSite> {
+    markFn(&mut f.clone())
+}
+struct Ctx {
+    name: String,
+    isMethod: bool,
+    hasSelf: bool,
+    locals: HashSet<String>,
+    sites: Vec<TailSite>,
+}
+fn markFn(f: &mut Fn) -> Vec<TailSite> {
+    let skip = f.is_export || f.name.starts_with("__test_");
+    let mut cx = Ctx {
+        name: f.name.clone(),
+        isMethod: f.type_param.is_some(),
+        hasSelf: f.has_self,
+        locals: f.params.iter().map(|p| p.name.clone()).collect(),
+        sites: Vec::new(),
+    };
+    for p in &mut f.params {
+        if let Some(d) = &mut p.default {
+            expr(&mut cx, d, false);
+        }
+    }
+    match &mut f.body {
+        FnBody::Expr(e) => expr(&mut cx, e, !skip),
+        FnBody::Block(b) => block(&mut cx, b, !skip, !skip),
+        FnBody::Extern => {}
+    }
+    cx.sites
+}
+fn block(cx: &mut Ctx, b: &mut Block, tail: bool, ret: bool) {
+    let n = b.stmts.len();
+    for (i, s) in b.stmts.iter_mut().enumerate() {
+        stmt(cx, s, tail && i + 1 == n, ret);
+    }
+}
+fn stmt(cx: &mut Ctx, s: &mut Stmt, tail: bool, ret: bool) {
+    match s {
+        Stmt::Assign(a) => {
+            for t in &mut a.targets {
+                match t {
+                    AssignTarget::Var(n) => {
+                        cx.locals.insert(n.clone());
+                    }
+                    AssignTarget::Field(o, _) => expr(cx, o, false),
+                }
+            }
+            for v in &mut a.values {
+                expr(cx, v, false);
+            }
+        }
+        Stmt::Break | Stmt::Continue | Stmt::Todo => {}
+        Stmt::Assert(c) => expr(cx, &mut c.cond, false),
+        Stmt::ForLoop(l) => {
+            cx.locals.extend(l.binders.iter().cloned());
+            expr(cx, &mut l.source, false);
+            for c in &mut l.clauses {
+                match c {
+                    ForClause::If(e) => expr(cx, e, false),
+                    ForClause::Bind(n, e) => {
+                        cx.locals.insert(n.clone());
+                        expr(cx, e, false)
+                    }
+                }
+            }
+            block(cx, &mut l.body, false, false);
+        }
+        Stmt::While(w) => {
+            expr(cx, &mut w.condition, false);
+            block(cx, &mut w.body, false, false);
+        }
+        Stmt::If(i) => {
+            expr(cx, &mut i.condition, false);
+            block(cx, &mut i.body, tail, ret);
+            for ei in &mut i.else_ifs {
+                expr(cx, &mut ei.condition, false);
+                block(cx, &mut ei.body, tail, ret);
+            }
+            if let Some(e) = &mut i.else_ {
+                block(cx, e, tail, ret);
+            }
+        }
+        Stmt::Match(m) => {
+            for s in &mut m.subjects {
+                expr(cx, s, false);
+            }
+            for c in &mut m.cases {
+                case(cx, c, tail, ret);
+            }
+        }
+        Stmt::Return(e) => {
+            if let Some(e) = e {
+                expr(cx, e, ret);
+            }
+        }
+        Stmt::Crash(e) => expr(cx, e, false),
+        Stmt::Expr(e, _, _) => expr(cx, e, tail),
+    }
+}
+fn case(cx: &mut Ctx, c: &mut Case, tail: bool, ret: bool) {
+    for p in &c.patterns {
+        pattern(cx, p);
+    }
+    if let Some(g) = &mut c.guard {
+        expr(cx, g, false);
+    }
+    block(cx, &mut c.body, tail, ret);
+}
+fn pattern(cx: &mut Ctx, p: &CasePattern) {
+    match p {
+        CasePattern::Name(n) => {
+            cx.locals.insert(n.clone());
+        }
+        CasePattern::Class { fields, .. } => fields.iter().for_each(|f| pattern(cx, f)),
+        _ => {}
+    }
+}
+fn args(cx: &mut Ctx, a: &mut [Arg]) {
+    for x in a {
+        match x {
+            Arg::Positional(e) | Arg::Keyword { value: e, .. } => expr(cx, e, false),
+        }
+    }
+}
+fn expr(cx: &mut Ctx, e: &mut Expr, tail: bool) {
+    match e {
+        Expr::FnCall(c) => {
+            args(cx, &mut c.args);
+            c.tail = if !tail {
+                TailKind::NotTail
+            } else if cx.locals.contains(&c.name) {
+                TailKind::Closure
+            } else if c.name == cx.name && !cx.isMethod {
+                TailKind::SelfCall
+            } else {
+                TailKind::Other
+            };
+            site(cx, c);
+        }
+        Expr::Attribute(a) => {
+            expr(cx, &mut a.object, false);
+            if let AttrKind::Method(c) = &mut a.attr {
+                args(cx, &mut c.args);
+                let onSelf = matches!(a.object, Expr::Self_);
+                c.tail = if !tail {
+                    TailKind::NotTail
+                } else if onSelf && cx.hasSelf && c.name == cx.name && cx.isMethod {
+                    TailKind::SelfCall
+                } else {
+                    TailKind::Other
+                };
+                site(cx, c);
+            }
+        }
+        Expr::Paren(x) => expr(cx, x, tail),
+        Expr::InlineIf(i) => {
+            expr(cx, &mut i.condition, false);
+            expr(cx, &mut i.then, tail);
+            expr(cx, &mut i.else_, tail);
+        }
+        Expr::Binary(b) => {
+            expr(cx, &mut b.left, false);
+            expr(cx, &mut b.right, false);
+        }
+        Expr::Unary(u) => expr(cx, &mut u.operand, false),
+        Expr::Bool(b) => {
+            expr(cx, &mut b.left, false);
+            expr(cx, &mut b.right, false);
+        }
+        Expr::Compare(c) => {
+            expr(cx, &mut c.left, false);
+            expr(cx, &mut c.right, false);
+        }
+        Expr::Not(x) | Expr::Try(x) => expr(cx, x, false),
+        Expr::Bang(b) => expr(cx, &mut b.value, false),
+        Expr::Catch(c) => {
+            expr(cx, &mut c.value, false);
+            match &mut c.handler {
+                CatchHandler::Default(d) => expr(cx, d, false),
+                CatchHandler::Block { binder, body } => {
+                    cx.locals.insert(binder.clone());
+                    block(cx, body, false, false);
+                }
+            }
+        }
+        Expr::Bind(b) => {
+            pattern(cx, &b.case.patterns[0]);
+            expr(cx, &mut b.value, false);
+            if let Some(g) = &mut b.case.guard {
+                expr(cx, g, false);
+            }
+        }
+        Expr::Yield(v) => v.iter_mut().for_each(|x| expr(cx, x, false)),
+        Expr::ClassCall(c) => {
+            for f in &mut c.fields {
+                expr(cx, &mut f.value, false);
+            }
+            if let Some(s) = &mut c.spread {
+                expr(cx, s, false);
+            }
+        }
+        Expr::String(s) => {
+            for p in &mut s.parts {
+                if let StringPart::Interp(x) = p {
+                    expr(cx, x, false);
+                }
+            }
+        }
+        Expr::Closure(c) => {
+            // Tail relative to the closure only; its params are locals.
+            cx.locals.extend(c.params.iter().cloned());
+            block(cx, &mut c.body, true, true);
+        }
+        Expr::ErrorValue(_)
+        | Expr::Int(_)
+        | Expr::Float(_)
+        | Expr::BoolLit(_)
+        | Expr::Self_
+        | Expr::Var(_)
+        | Expr::TypeName(_) => {}
+    }
+}
+fn site(cx: &mut Ctx, c: &FnCall) {
+    if c.tail != TailKind::NotTail {
+        cx.sites.push(TailSite { callee: c.name.clone(), kind: c.tail, line: c.line });
+    }
+}

plum-core/src/trmc.rs ADDED Viewed

@@ -0,0 +1,446 @@
+//! Tail recursion modulo cons. Rewrites a free fn whose tail position builds an
+//! inline-variant cell around exactly one direct self call,
+//!
+//! ```text
+//! fun map(xs, f) -> Link[B] = match xs
+//!   Nil => Nil
+//!   Cons(h, t) => Cons(head: f(h), tail: map(t, f))
+//! ```
+//!
+//! into plain loops (no new AST node kinds, no codegen support needed). The first
+//! loop is the original body with each recursive cell pushed onto an accumulator
+//! chain (`__acc = Cons(head: .., tail: __acc)`) and the parameters reassigned
+//! for the next iteration; a base case stores its value in `__r` and clears `__go` (not a `break`:
+//! a `break` inside an `if` inside a `match` arm inside a `while` hangs today). The second loop rebuilds the cells in order around `__r`, last cell
+//! first, so the result is the list the recursion would have produced.
+//!
+//! The classic form (allocate each cell with a hole and write it next iteration)
+//! needs field assignment on the cell, which the checker does not allow on the
+//! hidden records behind inline variants; this form needs none, at the price of
+//! allocating each cell twice. Evaluation order is unchanged: fields before the
+//! recursive one, then the recursive call's arguments, in source order.
+//!
+//! Only rewrites free, non-export fns whose return type is an enum with an inline
+//! variant and a nullary variant, with exactly one recursive field; fields after
+//! the recursive one must be plain variables or literals. Nothing under
+//! `try`/`!`/`catch`, closures or `yield`, no other `return`s outside tail
+//! position, no variadic params.
+use crate::ast::*;
+/// Rewrites every eligible fn of `src`; returns their names.
+pub fn rewrite(src: &mut Source) -> Vec<String> {
+    let enums: Vec<Enum> = src
+        .items
+        .iter()
+        .filter_map(|i| if let Item::Enum(e) = i { Some(e.clone()) } else { None })
+        .collect();
+    let mut done = Vec::new();
+    for item in &mut src.items {
+        if let Item::Fn(f) = item {
+            if let Some(nf) = rewriteFn(f, &enums) {
+                *f = nf;
+                done.push(f.name.clone());
+            }
+        }
+    }
+    done
+}
+struct Cx<'a> {
+    f: &'a Fn,
+    enums: &'a [Enum],
+    ret: Type,
+    /// The cons variant (record enum) and its declared field names.
+    cons: Option<(String, Vec<String>, usize)>,
+    nullary: String,
+    /// The variant of the return enum that wraps the cons record (`Link__Cons`).
+    wrapper: Option<String>,
+    consGenerics: Vec<Type>,
+    counter: usize,
+    found: bool,
+}
+fn rewriteFn(f: &Fn, enums: &[Enum]) -> Option<Fn> {
+    if f.is_export
+        || f.is_extern
+        || f.is_star
+        || f.type_param.is_some()
+        || f.has_self
+        || f.yields.is_some()
+        || f.name.starts_with("__test_")
+    {
+        return None;
+    }
+    if f.params.iter().any(|p| {
+        p.isOwn || p.default.is_some() || !matches!(p.ty, ParamType::Type(_) | ParamType::Fn(..))
+    }) {
+        return None;
+    }
+    let ret = f.returns.clone()?;
+    let owner = enums.iter().find(|e| e.name == ret.name && e.inlineOf.is_none())?;
+    let nullary = owner
+        .variants
+        .iter()
+        .find(|v| v.member.is_none() && v.fields.is_empty())?
+        .name
+        .clone();
+    let FnBody::Block(body) = &f.body else {
+        // `= if .. then .. else ..` bodies are expressions; handled below.
+        return rewriteExprBody(f, enums, ret, nullary);
+    };
+    let dbg = format!("{:?}", body);
+    if bannedText(&dbg) {
+        return None;
+    }
+    let mut cx = Cx { f, enums, ret, cons: None, nullary, wrapper: None, consGenerics: vec![], counter: 0, found: false };
+    let loopBody = cx.tailBlock(body.clone())?;
+    cx.finish(loopBody)
+}
+fn rewriteExprBody(f: &Fn, enums: &[Enum], ret: Type, nullary: String) -> Option<Fn> {
+    let FnBody::Expr(e) = &f.body else { return None };
+    if bannedText(&format!("{:?}", e)) {
+        return None;
+    }
+    let mut cx = Cx { f, enums, ret, cons: None, nullary, wrapper: None, consGenerics: vec![], counter: 0, found: false };
+    let stmts = cx.tailExpr(e.clone())?;
+    cx.finish(Block { stmts })
+}
+fn bannedText(dbg: &str) -> bool {
+    ["Try(", "Bang(", "Catch(", "Yield(", "Closure(", "Return(", "Todo", "Crash("]
+        .iter()
+        .any(|b| dbg.contains(b))
+}
+fn wrap(w: &Option<String>, e: Expr) -> Expr {
+    match w {
+        Some(w) => Expr::FnCall(FnCall {
+            name: w.clone(),
+            args: vec![Arg::Positional(e)],
+            line: 0,
+            column: 0,
+            tail: TailKind::NotTail,
+        }),
+        None => e,
+    }
+}
+fn var(n: &str) -> Expr {
+    Expr::Var(n.to_string())
+}
+fn declare(n: &str, ty: Option<Type>, e: Expr) -> Stmt {
+    Stmt::Assign(Assign {
+        targets: vec![AssignTarget::Var(n.to_string())],
+        values: vec![e],
+        declare: true,
+        ty,
+    })
+}
+fn set(n: &str, e: Expr) -> Stmt {
+    Stmt::Assign(Assign {
+        targets: vec![AssignTarget::Var(n.to_string())],
+        values: vec![e],
+        declare: false,
+        ty: None,
+    })
+}
+fn pure(e: &Expr) -> bool {
+    match e {
+        Expr::Var(_) | Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_) => true,
+        Expr::Paren(x) => pure(x),
+        _ => false,
+    }
+}
+fn mentions(e: &Expr, name: &str) -> bool {
+    format!("{:?}", e).contains(&format!("name: {:?}", name))
+}
+impl<'a> Cx<'a> {
+    fn fresh(&mut self, tag: &str) -> String {
+        self.counter += 1;
+        format!("__tc_{}{}", tag, self.counter)
+    }
+    /// Assembles the rewritten fn around the transformed body `loopBody`.
+    fn finish(self, loopBody: Block) -> Option<Fn> {
+        if !self.found {
+            return None;
+        }
+        let (cons, fields, rec) = self.cons.clone()?;
+        let mut stmts = vec![
+            declare("__tc_acc", Some(self.ret.clone()), Expr::TypeName(self.nullary.clone())),
+            declare("__tc_r", Some(self.ret.clone()), Expr::TypeName(self.nullary.clone())),
+            declare("__tc_go", None, Expr::Int(1)),
+            Stmt::While(While {
+                condition: Expr::Compare(Box::new(CompareExpr {
+                    op: CmpOp::Gt,
+                    left: var("__tc_go"),
+                    right: Expr::Int(0),
+                })),
+                body: loopBody,
+            }),
+        ];
+        // Rebuild: for every accumulated cell, last first, wrap `__tc_r` in a fresh one.
+        let binders: Vec<String> = (0..fields.len()).map(|i| format!("__tc_p{i}")).collect();
+        let args: Vec<FieldArg> = fields
+            .iter()
+            .zip(&binders)
+            .enumerate()
+            .map(|(i, (n, b))| FieldArg {
+                name: n.clone(),
+                value: if i == rec { var("__tc_r") } else { var(b) },
+            })
+            .collect();
+        let rebuild = Case {
+            patterns: vec![{
+                let inner = CasePattern::Class {
+                    name: cons.clone(),
+                    fields: binders.iter().map(|b| CasePattern::Name(b.clone())).collect(),
+                };
+                match &self.wrapper {
+                    Some(w) => CasePattern::Class { name: w.clone(), fields: vec![inner] },
+                    None => inner,
+                }
+            }],
+            guard: None,
+            body: Block {
+                stmts: vec![
+                    set(
+                        "__tc_r",
+                        wrap(
+                            &self.wrapper,
+                            Expr::ClassCall(ClassCall {
+                                type_name: cons,
+                                fields: args,
+                                generics: self.consGenerics.clone(),
+                                spread: None,
+                            }),
+                        ),
+                    ),
+                    set("__tc_acc", var(&binders[rec])),
+                ],
+            },
+        };
+        let stop = Case {
+            patterns: vec![CasePattern::Wildcard],
+            guard: None,
+            body: Block { stmts: vec![Stmt::Break] },
+        };
+        stmts.push(Stmt::While(While {
+            condition: Expr::BoolLit(true),
+            body: Block {
+                stmts: vec![Stmt::Match(Match {
+                    subjects: vec![var("__tc_acc")],
+                    cases: vec![rebuild, stop],
+                })],
+            },
+        }));
+        stmts.push(Stmt::Return(Some(var("__tc_r"))));
+        let mut nf = self.f.clone();
+        nf.body = FnBody::Block(Block { stmts });
+        Some(nf)
+    }
+    // ---- tail-position walk ----
+    fn tailBlock(&mut self, b: Block) -> Option<Block> {
+        let n = b.stmts.len();
+        let mut out = Vec::new();
+        for (i, s) in b.stmts.into_iter().enumerate() {
+            if i + 1 == n {
+                out.extend(self.tailStmt(s)?);
+            } else {
+                out.push(s);
+            }
+        }
+        Some(Block { stmts: out })
+    }
+    fn tailStmt(&mut self, s: Stmt) -> Option<Vec<Stmt>> {
+        match s {
+            Stmt::Expr(e, ..) => self.tailExpr(e),
+            Stmt::If(mut i) => {
+                i.else_.as_ref()?;
+                i.body = self.tailBlock(i.body)?;
+                for ei in &mut i.else_ifs {
+                    ei.body = self.tailBlock(std::mem::replace(&mut ei.body, Block { stmts: vec![] }))?;
+                }
+                i.else_ = Some(self.tailBlock(i.else_.take()?)?);
+                Some(vec![Stmt::If(i)])
+            }
+            Stmt::Match(mut m) => {
+                for c in &mut m.cases {
+                    c.body = self.tailBlock(std::mem::replace(&mut c.body, Block { stmts: vec![] }))?;
+                }
+                Some(vec![Stmt::Match(m)])
+            }
+            _ => None,
+        }
+    }
+    fn tailExpr(&mut self, e: Expr) -> Option<Vec<Stmt>> {
+        match e {
+            Expr::Paren(x) => self.tailExpr(*x),
+            Expr::InlineIf(i) => {
+                let i = *i;
+                let then = Block { stmts: self.tailExpr(i.then)? };
+                let else_ = Block { stmts: self.tailExpr(i.else_)? };
+                Some(vec![Stmt::If(If {
+                    condition: i.condition,
+                    body: then,
+                    else_ifs: vec![],
+                    else_: Some(else_),
+                })])
+            }
+            Expr::ClassCall(c) => match self.consLeaf(&c, None)? {
+                Some(stmts) => Some(stmts),
+                None => Some(self.baseLeaf(Expr::ClassCall(c))),
+            },
+            Expr::FnCall(fc) => {
+                let wrapped = match (&fc.args[..], self.enums.iter().find(|e| e.name == self.ret.name)) {
+                    ([Arg::Positional(Expr::ClassCall(inner))], Some(owner)) => owner
+                        .variants
+                        .iter()
+                        .any(|v| {
+                            v.name == fc.name
+                                && v.member.as_ref().map(|m| m.name.as_str())
+                                    == Some(inner.type_name.as_str())
+                        })
+                        .then(|| inner.clone()),
+                    _ => None,
+                };
+                if let Some(inner) = wrapped {
+                    match self.consLeaf(&inner, Some(fc.name.clone()))? {
+                        Some(stmts) => return Some(stmts),
+                        None => {}
+                    }
+                }
+                Some(self.baseLeaf(Expr::FnCall(fc)))
+            }
+            e => Some(self.baseLeaf(e)),
+        }
+    }
+    fn baseLeaf(&mut self, e: Expr) -> Vec<Stmt> {
+        vec![set("__tc_r", e), set("__tc_go", Expr::Int(0))]
+    }
+    /// `Ok(None)`-style: outer `None` aborts the whole rewrite; `Some(None)` means
+    /// this call is not a cons-with-self-call and is an ordinary base value.
+    fn consLeaf(&mut self, c: &ClassCall, wrapper: Option<String>) -> Option<Option<Vec<Stmt>>> {
+        let Some(rec) = self.enums.iter().find(|e| {
+            e.name == c.type_name
+                && e.isRecord
+                && e.inlineOf.as_deref() == Some(self.ret.name.as_str())
+        }) else {
+            return Some(None);
+        };
+        let selfName = self.f.name.clone();
+        let selfFields: Vec<usize> = c
+            .fields
+            .iter()
+            .enumerate()
+            .filter(|(_, f)| mentions(&f.value, &selfName))
+            .map(|(i, _)| i)
+            .collect();
+        if selfFields.is_empty() {
+            return Some(None);
+        }
+        let [k] = selfFields[..] else { return Some(None) };
+        let Expr::FnCall(call) = &c.fields[k].value else { return Some(None) };
+        if call.name != selfName || c.spread.is_some() {
+            return Some(None);
+        }
+        let declared = rec.variants.first()?.field_names.clone();
+        let mut given: Vec<&str> = c.fields.iter().map(|f| f.name.as_str()).collect();
+        given.sort();
+        let mut want: Vec<&str> = declared.iter().map(|s| s.as_str()).collect();
+        want.sort();
+        if given != want {
+            return Some(None);
+        }
+        // Fields after the recursive one run after the recursion in the original.
+        if !c.fields[k + 1..].iter().all(|f| pure(&f.value)) {
+            return Some(None);
+        }
+        let recName = c.fields[k].name.clone();
+        let recIdx = declared.iter().position(|n| *n == recName)?;
+        match &self.cons {
+            Some((n, _, i)) if *n != c.type_name || *i != recIdx || self.wrapper != wrapper => {
+                return None
+            }
+            _ => {
+                self.cons = Some((c.type_name.clone(), declared.clone(), recIdx));
+                self.wrapper = wrapper.clone();
+                self.consGenerics = c.generics.clone();
+            }
+        }
+        // New arguments, by parameter position.
+        let params = &self.f.params;
+        if call.args.len() != params.len() {
+            return None;
+        }
+        let mut newArgs: Vec<Option<Expr>> = vec![None; params.len()];
+        for (i, a) in call.args.iter().enumerate() {
+            match a {
+                Arg::Positional(x) => newArgs[i] = Some(x.clone()),
+                Arg::Keyword { name, value } => {
+                    let j = params.iter().position(|p| p.name == *name)?;
+                    newArgs[j] = Some(value.clone());
+                }
+            }
+        }
+        let newArgs: Vec<Expr> = newArgs.into_iter().collect::<Option<_>>()?;
+        if newArgs.iter().any(|a| matches!(a, Expr::TypeName(_))) {
+            return None;
+        }
+        self.found = true;
+        let mut stmts = Vec::new();
+        // Fields before the recursive one, in source order.
+        let mut fields = Vec::new();
+        for (i, f) in c.fields.iter().enumerate() {
+            if i == k {
+                fields.push(FieldArg { name: f.name.clone(), value: var("__tc_acc") });
+            } else if i < k && !pure(&f.value) {
+                let t = self.fresh("f");
+                stmts.push(declare(&t, None, f.value.clone()));
+                fields.push(FieldArg { name: f.name.clone(), value: var(&t) });
+            } else {
+                fields.push(f.clone());
+            }
+        }
+        // Arguments of the recursive call.
+        let mut moves = Vec::new();
+        for (p, a) in params.iter().zip(newArgs) {
+            if matches!(&a, Expr::Var(n) if *n == p.name) {
+                continue;
+            }
+            if matches!(a, Expr::Int(_) | Expr::Float(_) | Expr::BoolLit(_)) {
+                moves.push(set(&p.name, a));
+            } else {
+                let t = self.fresh("a");
+                stmts.push(declare(&t, None, a));
+                moves.push(set(&p.name, var(&t)));
+            }
+        }
+        stmts.push(set(
+            "__tc_acc",
+            wrap(
+                &wrapper,
+                Expr::ClassCall(ClassCall {
+                    type_name: c.type_name.clone(),
+                    fields,
+                    generics: c.generics.clone(),
+                    spread: None,
+                }),
+            ),
+        ));
+        stmts.extend(moves);
+        Some(Some(stmts))
+    }
+}

plum-core/tests/tail_test.rs ADDED Viewed

@@ -0,0 +1,134 @@
+#![allow(non_snake_case)]
+use plum_core::ast::*;
+use plum_core::tail::{markTailCalls, tailCalls, TailSite};
+use plum_core::AstParser;
+fn parse(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(!tree.root_node().has_error(), "{}", tree.root_node().to_sexp());
+    AstParser::new(src).parseSource(tree.root_node())
+}
+/// Tail calls of the first fn named `name` (a method: the one with that name).
+fn sites(src: &str, name: &str) -> Vec<(String, TailKind)> {
+    let s = parse(src);
+    let mut all = Vec::new();
+    for i in &s.items {
+        if let Item::Fn(f) = i {
+            if f.name == name {
+                all = tailCalls(f);
+            }
+        }
+    }
+    all.into_iter().map(|t| (t.callee, t.kind)).collect()
+}
+fn one(callee: &str, kind: TailKind) -> Vec<(String, TailKind)> {
+    vec![(callee.to_string(), kind)]
+}
+#[test]
+fn self_tail_in_match_arm() {
+    let src = "fun sumAcc(xs: Int, acc: Int) -> Int = match xs\n  0 => acc\n  n => sumAcc(n - 1, acc + n)\n";
+    let f = match &parse(src).items[0] {
+        Item::Fn(f) => f.clone(),
+        _ => panic!(),
+    };
+    assert_eq!(
+        tailCalls(&f),
+        vec![TailSite { callee: "sumAcc".into(), kind: TailKind::SelfCall, line: 3 }]
+    );
+}
+#[test]
+fn self_tail_in_if_else() {
+    let src = "fun f(n: Int) -> Int =\n  if n == 0\n    return 0\n  else\n    f(n - 1)\n";
+    assert_eq!(sites(src, "f"), one("f", TailKind::SelfCall));
+}
+#[test]
+fn not_tail_under_binary_op() {
+    let src = "fun length(xs: Int) -> Int = match xs\n  0 => 0\n  t => 1 + length(t)\n";
+    assert_eq!(sites(src, "length"), vec![]);
+}
+#[test]
+fn not_tail_as_argument() {
+    let src = "fun f(n: Int) -> Int = g(f(n))\n";
+    assert_eq!(sites(src, "f"), one("g", TailKind::Other));
+}
+#[test]
+fn not_tail_inside_try() {
+    let src = "fun f(n: Int) -> !Int =\n  try g(n)\n";
+    assert_eq!(sites(src, "f"), vec![]);
+    let src = "fun f(n: Int) -> Int =\n  g(n)!\n";
+    assert_eq!(sites(src, "f"), vec![]);
+}
+#[test]
+fn other_fn_tail() {
+    let src = "fun f(n: Int) -> Int = g(n)\n";
+    assert_eq!(sites(src, "f"), one("g", TailKind::Other));
+}
+#[test]
+fn mutual_recursion_both_tail() {
+    let src = "fun isEven(n: Int) -> Bool = if n == 0 then true else isOdd(n - 1)\nfun isOdd(n: Int) -> Bool = if n == 0 then false else isEven(n - 1)\n";
+    assert_eq!(sites(src, "isEven"), one("isOdd", TailKind::Other));
+    assert_eq!(sites(src, "isOdd"), one("isEven", TailKind::Other));
+}
+#[test]
+fn method_self_tail() {
+    let src = "record Counter(n: Int) =\n  fun count(self, k: Int) -> Int =\n    if k == 0 then self.n else self.count(k - 1)\n";
+    assert_eq!(sites(src, "count"), one("count", TailKind::SelfCall));
+}
+#[test]
+fn closure_value_call_tail() {
+    let src = "fun f(g: fn(Int) -> Int, n: Int) -> Int = g(n)\n";
+    assert_eq!(sites(src, "f"), one("g", TailKind::Closure));
+}
+#[test]
+fn return_expr_tail() {
+    let src = "fun f(n: Int) -> Int =\n  if n > 3\n    return f(n - 1)\n  n\n";
+    assert_eq!(sites(src, "f"), one("f", TailKind::SelfCall));
+}
+#[test]
+fn block_last_expr_tail() {
+    let src = "fun f(n: Int) -> Int =\n  x := n + 1\n  g(x)\n";
+    assert_eq!(sites(src, "f"), one("g", TailKind::Other));
+    let src = "fun f(n: Int) -> Int =\n  g(n)\n  n\n";
+    assert_eq!(sites(src, "f"), vec![]);
+}
+#[test]
+fn closure_body_is_tail_relative_to_closure() {
+    let src = "fun f(n: Int) -> Int =\n  h(|x| g(x))\n";
+    assert_eq!(
+        sites(src, "f"),
+        vec![("g".to_string(), TailKind::Other), ("h".to_string(), TailKind::Other)]
+    );
+    let src = "fun f(n: Int) -> Int =\n  k := h(|x| g(x))\n  n\n";
+    assert_eq!(sites(src, "f"), one("g", TailKind::Other));
+}
+#[test]
+fn mark_sets_field() {
+    let mut s = parse("fun f(n: Int) -> Int = f(n)\n");
+    markTailCalls(&mut s);
+    match &s.items[0] {
+        Item::Fn(f) => match &f.body {
+            FnBody::Expr(Expr::FnCall(c)) => assert_eq!(c.tail, TailKind::SelfCall),
+            b => panic!("{b:?}"),
+        },
+        _ => panic!(),
+    }
+}

plum-core/tests/trmc_test.rs ADDED Viewed

@@ -0,0 +1,287 @@
+#![allow(non_snake_case)]
+//! Tail recursion modulo cons (`plum_core::trmc`): which fns are rewritten, and
+//! that the rewrite computes what the recursion would (compiled and run through
+//! the real pipeline, which is where `trmc::rewrite` is wired in).
+use plum_wasm_codegen::compileSource;
+fn gcEngine() -> wasmtime::Engine {
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    wasmtime::Engine::new(&config).expect("engine with GC config should construct")
+}
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn load(name: &str, src: &str) -> plum_core::ast::Source {
+    let dir = std::env::temp_dir().join(format!("plum_trmc_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    r.unwrap_or_else(|e| panic!("load: {e}"))
+}
+/// Compiles `src` through the real pipeline and runs its `main() -> Int`.
+fn runInt(name: &str, src: &str) -> i64 {
+    let source = load(name, src);
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    wasmparser::validate(&bytes).expect("valid wasm");
+    let engine = gcEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+/// Whether the lowered program the checker hands codegen has `name` rewritten.
+fn isRewritten(name: &str, src: &str, fnName: &str) -> bool {
+    let source = load(name, src);
+    let info = plum_checker::typedSource(&source).unwrap_or_else(|e| panic!("check: {e:?}"));
+    let lowered = info.lowered.expect("lowered program");
+    lowered.items.iter().any(|i| match i {
+        plum_core::ast::Item::Fn(f) if f.name == fnName => format!("{:?}", f.body).contains("__tc_acc"),
+        _ => false,
+    })
+}
+/// Direct unit check of the pass on a lowered program.
+fn rewrittenNames(name: &str, src: &str) -> Vec<String> {
+    let source = load(name, src);
+    let info = plum_checker::typedSource(&source).unwrap();
+    // `typedSource` already rewrote; rewriting again must find nothing new to do
+    // only if the fns are already loops, so rewrite the pre-rewrite program.
+    let _ = info;
+    let mut s = source.clone();
+    plum_core::forms::begin(&s);
+    let lowered = {
+        let _ = plum_checker::checkSource(&s);
+        plum_core::forms::finish(&s)
+    };
+    s = lowered;
+    plum_core::trmc::rewrite(&mut s)
+}
+const HEAD: &str = "\
+import std/Str
+import std/Int
+import std/Bool
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun fromTo(a: Int, b: Int) -> Link[Int] =
+  if a >= b then Nil else Cons(head: a, tail: fromTo(a + 1, b))
+fun map(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
+fun append(xs: Link[T], ys: Link[T]) -> Link[T] = match xs
+  Nil => ys
+  Cons(h, t) => Cons(head: h, tail: append(t, ys))
+fun filter(xs: Link[T], keep: fn(T) -> Bool) -> Link[T] = match xs
+  Nil => Nil
+  Cons(h, t) =>
+    rest := filter(t, keep)
+    if keep(h) then Cons(head: h, tail: rest) else rest
+fun sum(xs: Link[Int]) -> Int =
+  cur := xs
+  total := 0
+  while true
+    match cur
+      Nil =>
+        break
+      Cons(h, t) =>
+        total = total + h
+        cur = t
+  return total
+fun count(xs: Link[T]) -> Int =
+  cur := xs
+  n := 0
+  while true
+    match cur
+      Nil =>
+        break
+      Cons(_, t) =>
+        n = n + 1
+        cur = t
+  return n
+fun toInt(xs: Link[Int]) -> Int =
+  cur := xs
+  r := 0
+  while true
+    match cur
+      Nil =>
+        break
+      Cons(h, t) =>
+        r = r * 10 + h
+        cur = t
+  return r
+";
+fn prog(body: &str) -> String {
+    format!("{HEAD}{body}")
+}
+#[test]
+fn map_rewritten_same_result() {
+    let p = prog(
+        "\
+fun mapRef(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
+  Cons(h, t) =>
+    rest := mapRef(t, f)
+    Cons(head: f(h), tail: rest)
+fun main() -> Int =
+  none: Link[Int] := Nil
+  a := map(none, |x| x + 1)
+  b := map(fromTo(0, 1), |x| x + 1)
+  c := map(fromTo(0, 50), |x| x * 3)
+  d := mapRef(fromTo(0, 50), |x| x * 3)
+  big := map(fromTo(0, 1000000), |x| x + 1)
+  if count(a) == 0 && sum(b) == 1 && sum(c) == sum(d) && toInt(map(fromTo(1, 6), |x| x * 2)) == 24690 && count(big) == 1000000 && sum(big) == 500000500000 then 1 else 0
+",
+    );
+    assert!(isRewritten("map1", &p, "map"));
+    assert!(!isRewritten("map2", &p, "mapRef"));
+    assert_eq!(runInt("map3", &p), 1);
+}
+#[test]
+fn filter_rewritten_same_result() {
+    let p = prog(
+        "\
+fun main() -> Int =
+  xs := fromTo(0, 20)
+  none: Link[Int] := Nil
+  evens := filter(xs, |x| x % 2 == 0)
+  if count(filter(none, |x| x > 0)) == 0 && sum(evens) == 90 && count(evens) == 10 then 1 else 0
+",
+    );
+    assert!(!isRewritten("filter1", &p, "filter"));
+    assert_eq!(runInt("filter2", &p), 1);
+}
+#[test]
+fn fromTo_rewritten() {
+    let p = prog(
+        "\
+fun main() -> Int =
+  big := fromTo(0, 1000000)
+  if count(fromTo(3, 3)) == 0 && count(fromTo(5, 2)) == 0 && toInt(fromTo(1, 5)) == 1234 && count(big) == 1000000 && sum(big) == 499999500000 then 1 else 0
+",
+    );
+    assert!(isRewritten("fromTo1", &p, "fromTo"));
+    assert_eq!(runInt("fromTo2", &p), 1);
+}
+#[test]
+fn append_rewritten() {
+    let p = prog(
+        "\
+fun main() -> Int =
+  none: Link[Int] := Nil
+  a := fromTo(0, 500000)
+  b := fromTo(500000, 1000000)
+  big := append(a, b)
+  if count(append(none, none)) == 0 && toInt(append(fromTo(1, 3), fromTo(3, 5))) == 1234 && toInt(append(none, fromTo(1, 4))) == 123 && toInt(append(fromTo(1, 4), none)) == 123 && count(big) == 1000000 && sum(big) == 499999500000 then 1 else 0
+",
+    );
+    assert!(isRewritten("append1", &p, "append"));
+    assert_eq!(runInt("append2", &p), 1);
+}
+#[test]
+fn two_recursive_fields_not_rewritten() {
+    let p = "\
+import std/Str
+import std/Int
+import std/Bool
+enum Tree = Empty | Node(left: Tree, value: Int, right: Tree)
+fun mapTree(t: Tree, f: fn(Int) -> Int) -> Tree = match t
+  Empty => Empty
+  Node(l, v, r) => Node(left: mapTree(l, f), value: f(v), right: mapTree(r, f))
+fun total(t: Tree) -> Int = match t
+  Empty => 0
+  Node(l, v, r) => total(l) + v + total(r)
+fun main() -> Int =
+  t := Node(left: Node(left: Empty, value: 1, right: Empty), value: 2, right: Node(left: Empty, value: 3, right: Empty))
+  total(mapTree(t, |x| x * 10))
+";
+    assert!(!isRewritten("tree1", p, "mapTree"));
+    assert_eq!(runInt("tree2", p), 60);
+}
+#[test]
+fn side_effect_order_kept() {
+    let p = prog(
+        "\
+record Log(n: Int)
+fun note(l: Log, x: Int) -> Int =
+  l.n = l.n * 10 + x
+  return x
+fun walk(xs: Link[Int], log: Log, tag: Int) -> Link[Int] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: note(log, h), tail: walk(t, log, note(log, 9)))
+fun main() -> Int =
+  log := Log(n: 0)
+  ys := walk(fromTo(1, 4), log, 0)
+  if toInt(ys) == 123 then log.n else 0
+",
+    );
+    assert!(isRewritten("order1", &p, "walk"));
+    // head 1, arg 9, head 2, arg 9, head 3, arg 9
+    assert_eq!(runInt("order2", &p), 192939);
+}
+#[test]
+fn pass_reports_names() {
+    let p = prog("fun main() -> Int = 0\n");
+    let names = rewrittenNames("names", &p);
+    assert!(names.contains(&"map".to_string()), "{names:?}");
+    assert!(names.contains(&"fromTo".to_string()), "{names:?}");
+    assert!(names.contains(&"append".to_string()), "{names:?}");
+    assert!(!names.contains(&"filter".to_string()), "{names:?}");
+}
+#[test]
+fn nested_if_in_arm_rewritten_same_result() {
+    let p = prog(
+        "\
+fun replaceNth(xs: Link[T], i: Int, x: T) -> Link[T] = match xs
+  Nil => Nil
+  Cons(h, t) => if i <= 0 then Cons(head: x, tail: t) else Cons(head: h, tail: replaceNth(t, i - 1, x))
+fun main() -> Int =
+  xs := fromTo(1, 6)
+  none: Link[Int] := Nil
+  if toInt(replaceNth(xs, 2, 9)) == 12945 && toInt(replaceNth(xs, 0, 7)) == 72345 && toInt(replaceNth(xs, 9, 7)) == 12345 && count(replaceNth(none, 1, 5)) == 0 then 1 else 0
+",
+    );
+    assert!(isRewritten("nth1", &p, "replaceNth"));
+    assert_eq!(runInt("nth2", &p), 1);
+}

plum-examples/tail_calls.plum ADDED Viewed

@@ -0,0 +1,90 @@
+# Tail calls: deep recursion that must not overflow the stack.
+#
+# Self tail calls compile to loops, other tail calls use `return_call`, and a
+# constructor wrapped self call (`Cons(head: f(h), tail: map(t, f))`) is rewritten
+# to a loop (tail recursion modulo cons). Building a long list is slow under
+# wasmtime GC, so list building tests use 200,000 cells; allocation free loops
+# use 1,000,000.
+module tail_calls
+import std/Int
+import std/Float
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun sumTo(n: Int, acc: Int) -> Int =
+  if n == 0 then acc else sumTo(n - 1, acc + n)
+fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun fromTo(a: Int, b: Int) -> Link[Int] =
+  if a >= b then Nil else Cons(head: a, tail: fromTo(a + 1, b))
+fun map(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: map(t, f))
+fun foldl(xs: Link[T], acc: A, f: fn(A, T) -> A) -> A = match xs
+  Nil => acc
+  Cons(h, t) => foldl(t, f(acc, h), f)
+fun length(xs: Link[T], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(_, t) => length(t, acc + 1)
+fun isEven(n: Int) -> Bool =
+  if n == 0 then true else isOdd(n - 1)
+fun isOdd(n: Int) -> Bool =
+  if n == 0 then false else isEven(n - 1)
+# `call` tail calls a closure value; `dec` tail calls `call`.
+fun call(f: fn(Int) -> Int, n: Int) -> Int = f(n)
+fun dec(n: Int) -> Int =
+  if n == 0 then 0 else call(dec, n - 1)
+own record Counter(n: Int, total: Int)
+fun spin(own c: Counter) -> Counter =
+  if c.n == 0 then c else spin(Counter(..c, n: c.n - 1, total: c.total + 2))
+fun depth(n: Int) -> Int =
+  if n == 0 then 0 else 1 + depth(n - 1)
+test "tail_sum_million"
+  assert sumTo(1000000, 0) == 500000500000
+test "tail_build_200k"
+  assert length(build(200000, Nil), 0) == 200000
+test "fold_200k"
+  xs := fromTo(0, 200000)
+  assert foldl(xs, 0, |a, x| a + x) == 19999900000
+test "mutual_even_odd_million"
+  assert isEven(1000000)
+  assert !isOdd(1000000)
+  assert isOdd(999999)
+test "trmc_map_200k"
+  ys := map(fromTo(0, 200000), |x| x + 1)
+  assert length(ys, 0) == 200000
+  assert foldl(ys, 0, |a, x| a + x) == 20000100000
+test "trmc_fromTo_200k"
+  xs := fromTo(0, 200000)
+  assert length(xs, 0) == 200000
+test "closure_tail_million"
+  assert dec(1000000) == 0
+test "own_record_loop_100k"
+  c := spin(Counter(n: 100000, total: 0))
+  assert c.n == 0
+  assert c.total == 200000
+# Non-tail recursion still uses the wasm stack. Measured limit under the 4 MiB
+# host stack: about 265,000 frames (260,000 passes, 270,000 traps) of `1 + depth(n - 1)`; tested well below it.
+test "tree_recursion_depth_recorded"
+  assert depth(100000) == 100000

plum-game/src/host.rs CHANGED Viewed

@@ -160,9 +160,11 @@ impl<B: Backend> PlumGame<B> {
     /// Instantiates `wasm`, requiring `init`, `update` and `draw` exports.
     pub fn load(wasm: &[u8], backend: B) -> Result<Self> {
         let mut config = wasmtime::Config::new();
-        config.wasm_tail_call(true);
         config.wasm_gc(true);
         config.wasm_function_references(true);
+        config.wasm_tail_call(true);
+        config.max_wasm_stack(4 << 20);
+        config.async_stack_size(8 << 20);
         let engine = Engine::new(&config)?;
         let module = Module::new(&engine, wasm)?;
         for name in ["init", "update", "draw"] {

plum-game/web-test/fixtures/stress_state_view_deep.plum ADDED Viewed

@@ -0,0 +1,202 @@
+# Variant of stress_state_view.plum: all 5000 dancers live in ONE Link (each records its
+# spinner index), so step recurses 5000 deep. Original header follows.
+# The stress scene of stress_pure_scene.plum written as state and view, now recursive:
+# 5000 sprites in 50 slowly rotating groups, 500 rects and 200 circles (sprites of a
+# 1x1 white texture), 50 texts with a changing number, drawn through a 0.8 camera.
+# `State` is recursive `Link` lists (each spinner owns the `Link` of its 100 dancers);
+# `step` is pure, a structural recursion that returns the next state; `view` is pure
+# and rebuilds the whole SceneNode tree every frame with recursive functions, which
+# `Picture.draw` interprets. Nothing is retained between frames but `State`. The
+# deepest recursion is the 700 drifters; no loops run in step or view.
+module stress_state_view
+import std/Str
+import std/Int
+import std/Float
+import std/List
+import std/game/Vec2
+import std/game/Color
+import std/game/Game
+import std/game/Picture
+primitive Counts =
+  Sprites = 5000
+  Rects = 500
+  Circles = 200
+  Texts = 50
+  Groups = 50
+  WorldW = 1600
+  WorldH = 900
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun mapLink(xs: Link[A], f: fn(A) -> B) -> Link[B] = match xs
+  Nil => Nil
+  Cons(h, t) => Cons(head: f(h), tail: mapLink(t, f))
+# The list f(i), f(i + 1) ... f(n - 1).
+fun rangeLink(i: Int, n: Int, f: fn(Int) -> T) -> Link[T] =
+  if i >= n then Nil else Cons(head: f(i), tail: rangeLink(i + 1, n, f))
+fun appendLink(xs: Link[T], ys: Link[T]) -> Link[T] = match xs
+  Nil => ys
+  Cons(h, t) => Cons(head: h, tail: appendLink(t, ys))
+# The element at `i`, or `dflt` past the end.
+fun nthOr(xs: Link[T], i: Int, dflt: T) -> T = match xs
+  Nil => dflt
+  Cons(h, t) => if i <= 0 then h else nthOr(t, i - 1, dflt)
+# The nodes f(x) for every x of `xs`, followed by `rest`.
+fun toNodes(xs: Link[T], f: fn(T) -> SceneNode, rest: Nodes) -> Nodes = match xs
+  Nil => rest
+  Cons(h, t) => More(head: f(h), tail: toNodes(t, f, rest))
+fun countNodes(ns: Nodes) -> Int = match ns
+  End => 0
+  More(_, t) => 1 + countNodes(t)
+# A sprite of the sheet inside its group, spinning about its centre.
+struct Dancer(gi: Int, id: Int, x: Float, y: Float, rotation: Float, srcX: Float)
+# A rotating group of dancers: top-left (x, y), pivot (75, 85).
+record Spinner(id: Int, x: Float, y: Float, rotation: Float)
+# A square of the white texture that moves by (dx, dy) per frame and wraps.
+struct Drifter(id: Int, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float, color: Color)
+# Shows "n <count>" and counts up each frame.
+struct Counter(id: Int, x: Float, y: Float, n: Int)
+record State(sheet: Int, white: Int, spinners: Link[Spinner], dancers: Link[Dancer], drifters: Link[Drifter], counters: Link[Counter])
+fun hue(i: Int) -> Color =
+  Color(r: Float(i % 7) / 7.0, g: Float(i % 5) / 5.0, b: 0.4 + Float(i % 3) / 5.0, a: 0.8)
+fun newDrifter(id: Int, c: Color, x: Float, y: Float, w: Float, h: Float, dx: Float, dy: Float) -> Drifter =
+  Drifter(id: id, x: x, y: y, w: w, h: h, dx: dx, dy: dy, color: c)
+fun newDancer(gi: Int, j: Int) -> Dancer =
+  i := gi * {Counts.Sprites / Counts.Groups} + j
+  Dancer(gi: gi, id: 1000 + i, x: Float({j * j * 13 + j * 37} % 150), y: Float({j * j * 29 + j * 53} % 170), rotation: Float(i), srcX: Float(i % 4 * 16))
+fun newSpinner(gi: Int) -> Spinner =
+  Spinner(id: 100 + gi, x: Float(gi % 10 * 160), y: Float(gi / 10 * 180), rotation: 0.0)
+# All dancers, group after group, built by recursion over the spinner index.
+fun allDancers(gi: Int) -> Link[Dancer] =
+  if gi >= Counts.Groups then Nil else appendLink(rangeLink(0, Counts.Sprites / Counts.Groups, |j| newDancer(gi, j)), allDancers(gi + 1))
+fun newState(sheet: Int, white: Int) -> State =
+  rects := rangeLink(0, Counts.Rects, |i| newDrifter(10000 + i, hue(i), Float(i * 61 % Counts.WorldW), Float(i * 29 % Counts.WorldH), 12.0, 8.0, 2.0, 0.0))
+  circles := rangeLink(0, Counts.Circles, |i| newDrifter(20000 + i, hue(i + 3), Float(i * 83 % Counts.WorldW), Float(i * 47 % Counts.WorldH), 12.0, 12.0, 3.0, 1.0))
+  State(
+    sheet: sheet, white: white, spinners: rangeLink(0, Counts.Groups, |gi| newSpinner(gi)), dancers: allDancers(0),
+    drifters: appendLink(rects, circles),
+    counters: rangeLink(0, Counts.Texts, |i| Counter(id: 30000 + i, x: Float(i * 30 % Counts.WorldW), y: Float(i * 17 % Counts.WorldH), n: i)))
+# --- step: pure ---
+fun stepDrifter(d: Drifter) -> Drifter =
+  nx := d.x + d.dx
+  ny := d.y + d.dy
+  if nx > Float(Counts.WorldW)
+    nx = nx - Float(Counts.WorldW)
+  if ny > Float(Counts.WorldH)
+    ny = ny - Float(Counts.WorldH)
+  Drifter(id: d.id, x: nx, y: ny, w: d.w, h: d.h, dx: d.dx, dy: d.dy, color: d.color)
+fun stepDancer(d: Dancer, dt: Float) -> Dancer =
+  Dancer(gi: d.gi, id: d.id, x: d.x, y: d.y, rotation: d.rotation + 1.2 * dt, srcX: d.srcX)
+fun stepSpinner(p: Spinner, dt: Float) -> Spinner =
+  Spinner(id: p.id, x: p.x, y: p.y, rotation: p.rotation + 0.24 * dt)
+fun stepCounter(c: Counter) -> Counter =
+  Counter(id: c.id, x: c.x, y: c.y, n: c.n + 1)
+fun step(s: State, dt: Float) -> State =
+  State(
+    sheet: s.sheet, white: s.white, spinners: mapLink(s.spinners, |p| stepSpinner(p, dt)), dancers: mapLink(s.dancers, |d| stepDancer(d, dt)),
+    drifters: mapLink(s.drifters, |d| stepDrifter(d)), counters: mapLink(s.counters, |c| stepCounter(c)))
+# --- view: pure, the whole tree every frame ---
+fun dancerView(sheet: Int, d: Dancer) -> SceneNode =
+  Group(
+    transform: Compose(first: Translate(dx: d.x + 8.0, dy: d.y + 8.0), then: Compose(first: Rotate(radians: d.rotation), then: Translate(dx: 0.0 - 8.0, dy: 0.0 - 8.0))),
+    children: More(head: Sprite(
+      tex: sheet, x: 0.0, y: 0.0, w: 16.0, h: 16.0, srcX: d.srcX, srcY: 0.0, srcW: 16.0, srcH: 16.0,
+      tint: Color.White), tail: End))
+# The leading dancers of `ds` that belong to group `gi`, as nodes.
+fun groupNodes(sheet: Int, ds: Link[Dancer], gi: Int) -> Nodes = match ds
+  Nil => End
+  Cons(h, t) => if h.gi == gi then More(head: dancerView(sheet, h), tail: groupNodes(sheet, t, gi)) else End
+# `ds` without its leading dancers of group `gi`.
+fun dropGroup(ds: Link[Dancer], gi: Int) -> Link[Dancer] = match ds
+  Nil => Nil
+  Cons(h, t) => if h.gi == gi then dropGroup(t, gi) else ds
+fun spinnerView(sheet: Int, p: Spinner, ds: Link[Dancer]) -> SceneNode =
+  Group(
+    transform: Compose(first: Translate(dx: p.x + 75.0, dy: p.y + 85.0), then: Compose(first: Rotate(radians: p.rotation), then: Translate(dx: 0.0 - 75.0, dy: 0.0 - 85.0))),
+    children: groupNodes(sheet, ds, p.id - 100))
+# Spinner groups in order, each taking its dancers from the front of the one list.
+fun spinnerNodes(sheet: Int, ps: Link[Spinner], ds: Link[Dancer], rest: Nodes) -> Nodes = match ps
+  Nil => rest
+  Cons(p, t) => More(head: spinnerView(sheet, p, ds), tail: spinnerNodes(sheet, t, dropGroup(ds, p.id - 100), rest))
+fun drifterView(white: Int, d: Drifter) -> SceneNode =
+  Sprite(
+    tex: white, x: d.x, y: d.y, w: d.w, h: d.h, srcX: 0.0, srcY: 0.0, srcW: 0.0, srcH: 0.0,
+    tint: d.color)
+fun counterView(c: Counter) -> SceneNode =
+  Text(text: "n {c.n}", x: c.x, y: c.y, size: 14.0, color: Color.White)
+fun view(s: State) -> SceneNode =
+  texts := toNodes(s.counters, |c| counterView(c), End)
+  drifts := toNodes(s.drifters, |d| drifterView(s.white, d), texts)
+  Group(transform: Scale(sx: 0.8, sy: 0.8), children: spinnerNodes(s.sheet, s.spinners, s.dancers, drifts))
+fun whiteTexture() -> Int =
+  t := textureCreate(1, 1)
+  renderTarget(t)
+  clear(Color.White)
+  renderTarget(-1)
+  t
+record World(state: State)
+export fun init() -> World =
+  World(state: newState(textureLoad("sprites.png"), whiteTexture()))
+export fun update(w: World, dt: Float) =
+  w.state = step(w.state, dt)
+export fun draw(w: World) =
+  clear(Color.rgb(0.05, 0.06, 0.1))
+  Picture.draw(view(w.state))
+test "ten frames of step run"
+  s := newState(0, 0)
+  for i := range 10
+    s = step(s, 0.016)
+  assert nthOr(s.counters, 3, Counter(id: 0, x: 0.0, y: 0.0, n: 0)).n == 13
+  assert {nthOr(s.drifters, 0, newDrifter(0, Color.White, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)).x - 20.0}.abs() < 0.000001
+  assert {nthOr(s.dancers, 0, newDancer(0, 0)).rotation - 0.192}.abs() < 0.000001
+test "view has one node per actor"
+  s := newState(0, 0)
+  v := view(s)
+  match v
+    Group(_, kids) =>
+      assert countNodes(kids) == 50 + 500 + 200 + 50
+    _ =>
+      assert false
+test "dancers in one list 5000"
+  s := newState(0, 0)
+  assert countNodes(toNodes(s.dancers, |d| dancerView(0, d), End)) == 5000

plum-runtime/src/main.rs CHANGED Viewed

@@ -359,9 +359,11 @@ fn main() {
     // GC + typed function references are required to load modules containing
     // Plum's structs/enums/strings/closures (see docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).
     let mut config = wasmtime::Config::new();
-    config.wasm_tail_call(true);
     config.wasm_gc(true);
     config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    config.max_wasm_stack(4 << 20);
+    config.async_stack_size(8 << 20);
     let engine = wasmtime::Engine::new(&config).expect("engine with GC config should construct");
     let module = wasmtime::Module::new(&engine, WASM_BYTES).expect("embedded wasm should be valid");

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -398,6 +398,8 @@ type ClosureSigKey = (Vec<ValType>, Vec<ValType>);
 /// Global, read-only lookup tables shared by every function body being compiled.
 pub struct CompileCtx<'a> {
+    /// Number of imported functions (their indices come first).
+    pub import_count: u32,
     pub func_ids: HashMap<String, u32>,
     pub func_sigs: HashMap<String, FuncSig>,
     /// Instantiation id -> its wasm function and signature.
@@ -495,18 +497,12 @@ struct LocalCtx<'a> {
     /// statements in order, mirroring `plum-checker`'s own env evolution — needed
     /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
     type_env: RefCell<TypeEnv>,
-    /// How many wasm structured blocks (`if`/`else`) currently lie between the
-    /// point being compiled and its NEAREST ENCLOSING LOOP's own `block`/`loop`
+    /// `tail_depth` as it stood when the NEAREST ENCLOSING LOOP's body began.
-    /// pair — used by `Stmt::Break`/`Stmt::Continue` to compute the right `br`
+    /// `Stmt::Break`/`Stmt::Continue` branch over `tail_depth - loop_base_depth`
-    /// target depth. Reset to 0 on entering a loop's own body (a nested loop
-    /// starts counting fresh, relative to itself); incremented by 1 around each
+    /// wasm `if`s (every one is `TailDepth`-guarded: if/else-if chains, match
-    /// `compileCaseBody` call (`if`/`match` arm bodies), the only places that
-    /// add a structured block without being a loop themselves. Without this,
+    /// pattern tests and `when` guards, catch blocks) before reaching the loop's
-    /// `break`/`continue` inside an `if` nested in a loop silently computed the
+    /// own `block`/`loop` pair. A nested loop re-bases it for its own body.
-    /// WRONG branch depth (hardcoded as if directly in the loop body) and fell
-    /// through to the next statement instead of skipping/exiting — see the
-    /// `plum_compiler_bugs_found_2026_08` memory.
-    loop_extra_depth: Cell<u32>,
+    loop_base_depth: Cell<u32>,
     /// The declared return type of the function being compiled (`None` inside a
     /// closure body) — `?` builds the OUTER function's error result from it.
     ret_type: Option<PlumType>,
@@ -516,6 +512,40 @@ struct LocalCtx<'a> {
     /// Match-subject scratch local -> the subject's full plum type (type arguments
     /// included), so constructor patterns can instantiate their payload types.
     subject_ptypes: RefCell<HashMap<u32, PlumType>>,
+    /// The fn being compiled, when its calls in tail position may be tail calls
+    /// (`None` in a closure body or a const initializer).
+    self_func: Option<SelfFunc>,
+    /// Wasm blocks (`if` arms) between the point being compiled and the fn body's
+    /// self-tail-call `loop` (see `TailDepth`).
+    tail_depth: Cell<u32>,
+    /// Imported function count: calls to imports are never tail calls.
+    import_count: u32,
+}
+/// What tail-call emission needs to know about the fn being compiled.
+struct SelfFunc {
+    idx: u32,
+    /// Wasm result types of this fn.
+    ret: Vec<ValType>,
+    /// Whether the body is wrapped in a `loop` that self tail calls branch back to.
+    looped: bool,
+}
+/// RAII marker for one enclosing wasm `if` between a self tail call and the fn
+/// body's loop; held from the `if` emission to the end of the emitting scope.
+struct TailDepth<'a>(&'a Cell<u32>);
+impl<'a> TailDepth<'a> {
+    fn enter(c: &'a Cell<u32>) -> Self {
+        c.set(c.get() + 1);
+        TailDepth(c)
+    }
+}
+impl Drop for TailDepth<'_> {
+    fn drop(&mut self) {
+        self.0.set(self.0.get() - 1);
+    }
 }
 fn fnKey(f: &ast::Fn) -> String {
@@ -2859,7 +2889,7 @@ fn compileSourceInner(
         for i in 0..sig.params.len() {
             Instruction::LocalGet((i + 1) as u32).encode(&mut tbody);
         }
-        Instruction::Call(real_func_idx).encode(&mut tbody);
+        Instruction::ReturnCall(real_func_idx).encode(&mut tbody);
         Instruction::End.encode(&mut tbody);
         let func_idx = module.addFunction(type_idx, &tbody);
         module.nameFunction(func_idx, &format!("{}.trampoline", name));
@@ -2917,6 +2947,7 @@ fn compileSourceInner(
     module.functions[start_slot].1 = final_start_body;
     let ctx = CompileCtx {
+        import_count: module.func_import_count,
         func_ids,
         func_sigs,
         inst_funcs,
@@ -4609,80 +4640,6 @@ fn isBuiltConstInit(e: &ast::Expr) -> bool {
     }
 }
-thread_local! {
-    /// Addresses of the call expressions in tail position of the function body being
-    /// compiled (see `collectTailCalls`); a call here MAY become a `return_call`
-    /// (see `tailCallOk`). Reset per function.
-    static TAIL_EXPRS: RefCell<std::collections::HashSet<usize>> = RefCell::new(Default::default());
-}
-fn collectTailBlock(block: &ast::Block, out: &mut std::collections::HashSet<usize>) {
-    if let Some(last) = block.stmts.last() {
-        collectTailStmt(last, out);
-    }
-    for stmt in &block.stmts {
-        if let ast::Stmt::Return(Some(e)) = stmt {
-            collectTailExpr(e, out);
-        }
-    }
-}
-fn collectTailStmt(stmt: &ast::Stmt, out: &mut std::collections::HashSet<usize>) {
-    match stmt {
-        ast::Stmt::Expr(e, ..) | ast::Stmt::Return(Some(e)) => collectTailExpr(e, out),
-        ast::Stmt::If(i) => {
-            collectTailBlock(&i.body, out);
-            for ei in &i.else_ifs {
-                collectTailBlock(&ei.body, out);
-            }
-            if let Some(b) = &i.else_ {
-                collectTailBlock(b, out);
-            }
-        }
-        ast::Stmt::Match(m) => {
-            for c in &m.cases {
-                collectTailBlock(&c.body, out);
-            }
-        }
-        _ => {}
-    }
-}
-fn collectTailExpr(e: &ast::Expr, out: &mut std::collections::HashSet<usize>) {
-    match e {
-        ast::Expr::FnCall(_) => {
-            out.insert(e as *const ast::Expr as usize);
-        }
-        ast::Expr::Attribute(a) if matches!(a.attr, ast::AttrKind::Method(_)) => {
-            out.insert(e as *const ast::Expr as usize);
-        }
-        ast::Expr::InlineIf(t) => {
-            collectTailExpr(&t.then, out);
-            collectTailExpr(&t.else_, out);
-        }
-        _ => {}
-    }
-}
-/// Whether the call `expr` (callee wasm results `callee_ret`) may be emitted as a
-/// tail call: it is in tail position and its value is returned as-is — same Plum
-/// type as the function's own return type, no error-union wrap, same wasm results.
-fn tailCallOk(expr: &ast::Expr, callee_ret: &[ValType], ctx: &LocalCtx) -> bool {
-    let key = expr as *const ast::Expr as usize;
-    if !TAIL_EXPRS.with(|t| t.borrow().contains(&key)) {
-        return false;
-    }
-    let Some(rt) = &ctx.ret_type else { return false };
-    if matches!(rt, PlumType::TUnit) || ctx.types.contains_key(&(key + plum_checker::ERR_WRAP)) {
-        return false;
-    }
-    if inferLocalType(expr, ctx) != *rt {
-        return false;
-    }
-    let own = withGcTypes(|g| flatValtypes(rt, g));
-    own.as_slice() == callee_ret
-}
 /// Compiles a function body. With `const_init`, `f` is a bodyless stand-in and the
 /// body is the lazily-run, cache-once initializer of that const, returning its value.
 fn compileFnBodyImpl(
@@ -4709,6 +4666,28 @@ fn compileFnBodyImpl(
         decl_types.insert(p.name.clone(), ty.clone());
     }
+    // Tail calls: only real fns with a plain (non error-union) result.
+    let self_func = if const_init.is_some() || matches!(ret_decl, PlumType::TErr(..)) {
+        None
+    } else {
+        let own = match unit.inst {
+            Some(id) => ctx.inst_funcs.get(&id).map(|(i, s)| (*i, s.ret.clone())),
+            None => ctx
+                .func_ids
+                .get(&fnKey(f))
+                .zip(ctx.func_sigs.get(&fnKey(f)))
+                .map(|(i, s)| (*i, s.ret.clone())),
+        };
+        own.map(|(idx, ret)| SelfFunc {
+            idx,
+            ret,
+            looped: !matches!(f.body, ast::FnBody::Extern)
+                && plum_core::tail::tailCalls(f)
+                    .iter()
+                    .any(|t| t.kind == ast::TailKind::SelfCall),
+        })
+    };
     let mut collector = Collector {
         types: unit.types,
         enum_variants: &ctx.enum_variants,
@@ -4818,10 +4797,13 @@ fn compileFnBodyImpl(
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
-        loop_extra_depth: Cell::new(0),
+        loop_base_depth: Cell::new(0),
         ret_type: f.returns.as_ref().map(|_| ret_decl.clone()),
         match_subject_types: RefCell::new(HashMap::new()),
         subject_ptypes: RefCell::new(HashMap::new()),
+        self_func,
+        tail_depth: Cell::new(0),
+        import_count: ctx.import_count,
     };
     let result_vt = if f.returns.is_none() || matches!(ret_decl, PlumType::TUnit) {
@@ -4841,18 +4823,10 @@ fn compileFnBodyImpl(
         Instruction::End.encode(&mut body);
         return Ok(body);
     }
-    let mut tail = std::collections::HashSet::new();
+    let looped = local_ctx.self_func.as_ref().is_some_and(|s| s.looped);
-    match &f.body {
+    if looped {
-        ast::FnBody::Expr(e) => collectTailExpr(e, &mut tail),
+        Instruction::Loop(blockTypeFor(result_vt)).encode(&mut body);
-        ast::FnBody::Block(block)
-            if !matches!(&ret_decl, PlumType::TErr(t, _) if matches!(**t, PlumType::TUnit)) =>
-        {
-            collectTailBlock(block, &mut tail)
-        }
-        _ => {}
     }
-    TAIL_EXPRS.with(|t| *t.borrow_mut() = tail);
-    let result = (|| -> Result<(), String> {
     match &f.body {
         ast::FnBody::Expr(e) => {
             compileExpr(e, &mut body, &local_ctx, state)?;
@@ -4872,11 +4846,10 @@ fn compileFnBodyImpl(
         // `fns` excludes every `extern fun` (no body to compile).
         ast::FnBody::Extern => unreachable!("extern fns are excluded from `fns`"),
     }
-    Ok(())
-    })();
-    TAIL_EXPRS.with(|t| t.borrow_mut().clear());
-    result?;
+    if looped {
+        Instruction::End.encode(&mut body);
+    }
     Instruction::End.encode(&mut body);
     Ok(body)
 }
@@ -4903,17 +4876,12 @@ fn compileCaseBody(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    // Every caller (an `if`/`else if`/`else` body, or a `match` arm body) wraps
-    // this block in exactly one MORE wasm `if` construct than its own caller —
-    // tracked here (not at each call site) so it can't be missed on an error
+    // The enclosing wasm `if`s are counted by the callers' `TailDepth` guards;
-    // path; see `loop_extra_depth`'s doc comment for why this matters.
+    // see `loop_base_depth`.
-    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() + 1);
-    let result = match result_vt {
+    match result_vt {
         Some(vt) => compileBlockInValuePosition(block, vt, body, ctx, state),
         None => compileBlock(block, body, ctx, state),
-    };
+    }
-    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() - 1);
-    result
 }
 /// Compiles a block whose value must be produced when control reaches its end — every
@@ -5027,12 +4995,15 @@ fn compileIf(
     let bt = blockTypeFor(result_vt);
     compileBoolConditionAsI32(&if_.condition, body, ctx, state)?;
     Instruction::If(bt).encode(body);
+    // One entry per open wasm `if` (the else-if chain nests), for tail-call depth.
+    let mut depth_guards = vec![TailDepth::enter(&ctx.tail_depth)];
     compileCaseBody(&if_.body, result_vt, body, ctx, state)?;
     if !if_.else_ifs.is_empty() || if_.else_.is_some() {
         Instruction::Else.encode(body);
         for ei in &if_.else_ifs {
             compileBoolConditionAsI32(&ei.condition, body, ctx, state)?;
             Instruction::If(bt).encode(body);
+            depth_guards.push(TailDepth::enter(&ctx.tail_depth));
             compileCaseBody(&ei.body, result_vt, body, ctx, state)?;
             Instruction::Else.encode(body);
         }
@@ -5299,9 +5270,9 @@ fn compileStmt(
             // nearest target — reset the depth counter to 0 for its body, then
             // restore whatever it was (an outer loop's own count, if this loop
             // is itself nested inside an `if` inside another loop) afterward.
-            let saved_depth = ctx.loop_extra_depth.replace(0);
+            let saved_depth = ctx.loop_base_depth.replace(ctx.tail_depth.get());
             let result = compileBlock(&w.body, body, ctx, state);
-            ctx.loop_extra_depth.set(saved_depth);
+            ctx.loop_base_depth.set(saved_depth);
             result?;
             Instruction::Br(0).encode(body);
             Instruction::End.encode(body);
@@ -5315,10 +5286,10 @@ fn compileStmt(
             }
         }
         ast::Stmt::Break => {
-            Instruction::Br(ctx.loop_extra_depth.get() + 1).encode(body);
+            Instruction::Br(ctx.tail_depth.get() - ctx.loop_base_depth.get() + 1).encode(body);
         }
         ast::Stmt::Continue => {
-            Instruction::Br(ctx.loop_extra_depth.get()).encode(body);
+            Instruction::Br(ctx.tail_depth.get() - ctx.loop_base_depth.get()).encode(body);
         }
         ast::Stmt::Match(m) => {
             compileMatch(m, body, ctx, state, None)?;
@@ -5551,6 +5522,7 @@ fn compileTagPattern(
     pat: &ast::CasePattern,
     load: &dyn Fn(&mut Vec<u8>),
     result_vt: Option<ValType>,
+    depth: &Cell<u32>,
     body: &mut Vec<u8>,
     state: &mut ModuleState,
     on_match: &mut dyn FnMut(&mut Vec<u8>, &mut ModuleState) -> Result<(), String>,
@@ -5563,6 +5535,7 @@ fn compileTagPattern(
     Instruction::I32Const(errCode(name)?).encode(body);
     Instruction::I32Eq.encode(body);
     Instruction::If(blockTypeFor(result_vt)).encode(body);
+    let _tg = TailDepth::enter(depth);
     on_match(body, state)?;
     Instruction::Else.encode(body);
     on_fail(body, state)?;
@@ -5720,6 +5693,7 @@ fn compileCasePositions(
             Some(guard) => {
                 compileBoolConditionAsI32(guard, body, ctx, state)?;
                 Instruction::If(blockTypeFor(result_vt)).encode(body);
+                let _tg = TailDepth::enter(&ctx.tail_depth);
                 compileCaseBody(&case.body, result_vt, body, ctx, state)?;
                 Instruction::Else.encode(body);
                 compileMatchArmsMulti(
@@ -5749,6 +5723,7 @@ fn compileCasePositions(
                 pat,
                 &|b: &mut Vec<u8>| Instruction::LocalGet(scratch_local).encode(b),
                 result_vt,
+                &ctx.tail_depth,
                 body,
                 state,
                 &mut |body, state| {
@@ -5800,6 +5775,7 @@ fn compileCasePositions(
                 Instruction::I32Eqz.encode(body);
             }
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileCasePositions(
                 case,
                 pos + 1,
@@ -5883,6 +5859,7 @@ fn compileCasePositions(
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileCasePositions(
                 case,
                 pos + 1,
@@ -5974,6 +5951,7 @@ fn compileVariantEqArm(
     Instruction::LocalGet(scratch_local).encode(body);
     Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
     Instruction::If(blockTypeFor(result_vt)).encode(body);
+    let _tg = TailDepth::enter(&ctx.tail_depth);
     compileCasePositions(
         case,
         pos + 1,
@@ -6075,6 +6053,7 @@ fn compileVariantConstructorArm(
     Instruction::LocalGet(scratch_local).encode(body);
     Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
     Instruction::If(blockTypeFor(result_vt)).encode(body);
+    let _tg = TailDepth::enter(&ctx.tail_depth);
     // Narrow the subject down to this variant's concrete type before destructuring
     // its fields — valid here specifically because the ref.test just above proved it.
     Instruction::LocalGet(scratch_local).encode(body);
@@ -6283,6 +6262,7 @@ fn compileFieldPatterns(
                 Instruction::I32Eqz.encode(body);
             }
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileFieldPatterns(
                 fields,
                 field_types,
@@ -6399,6 +6379,7 @@ fn compileFieldPatterns(
             );
             Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileFieldPatterns(
                 fields,
                 field_types,
@@ -6444,6 +6425,7 @@ fn compileFieldPatterns(
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileFieldPatterns(
                 fields,
                 field_types,
@@ -6602,6 +6584,7 @@ fn compileFieldPatterns(
             );
             Instruction::RefTestNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             // Narrow into `nested_local` now that ref.test just above proved it's safe.
             emitContainerField(
                 body,
@@ -7078,10 +7061,8 @@ fn compileErrCatch(
     Instruction::If(resultBlock(&op.success)).encode(body);
     match &c.handler {
         ast::CatchHandler::Default(d) => {
-            ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() + 1);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
-            let r = compileExprInto(d, &op.success, body, ctx, state);
+            compileExprInto(d, &op.success, body, ctx, state)?;
-            ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() - 1);
-            r?;
         }
         ast::CatchHandler::Block { binder, body: blk } => {
             let names = errSite(expr).map(|s| s.names).unwrap_or_default();
@@ -7101,6 +7082,7 @@ fn compileErrCatch(
             } else {
                 Some(plumTypeToValtype(&op.success))
             };
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileCaseBody(blk, rvt, body, ctx, state)?;
         }
     }
@@ -7147,7 +7129,7 @@ fn compileErrAndThen(
         .stmts
         .split_last()
         .ok_or_else(|| "codegen: empty '?.' body".to_string())?;
-    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() + 1);
+    let _tg = TailDepth::enter(&ctx.tail_depth);
     for st in rest {
         compileStmt(st, body, ctx, state)?;
     }
@@ -7156,7 +7138,6 @@ fn compileErrAndThen(
     };
     // The checker recorded the body's coercion into the result's layout.
     compileExpr(e, body, ctx, state)?;
-    ctx.loop_extra_depth.set(ctx.loop_extra_depth.get() - 1);
     Instruction::End.encode(body);
     Ok(())
 }
@@ -7452,6 +7433,7 @@ fn compileExprCore(
             let result_vt = plumTypeToValtype(&inferLocalType(expr, ctx));
             compileBoolConditionAsI32(&t.condition, body, ctx, state)?;
             Instruction::If(blockTypeFor(Some(result_vt))).encode(body);
+            let _tg = TailDepth::enter(&ctx.tail_depth);
             compileExpr(&t.then, body, ctx, state)?;
             Instruction::Else.encode(body);
             compileExpr(&t.else_, body, ctx, state)?;
@@ -7543,11 +7525,7 @@ fn compileExprCore(
                 let (func_idx, sig) = resolveCallee(ctx, expr, false, &call.name)
                     .ok_or_else(|| format!("unknown function '{}'", call.name))?;
                 compileCallArgs(&call.name, &call.args, sig, body, ctx, state)?;
-                if tailCallOk(expr, &sig.ret, ctx) {
+                emitCall(func_idx, sig, call.tail, expr, body, ctx);
-                    Instruction::ReturnCall(func_idx).encode(body);
-                } else {
-                    Instruction::Call(func_idx).encode(body);
-                }
             }
         }
         ast::Expr::Self_ => {
@@ -7814,6 +7792,73 @@ fn compileExprCore(
 /// built into one GC array, and the declared defaults for omitted trailing params.
 /// The wasm function (and signature) a call expression invokes: its checked
 /// instantiation if the callee is generic, else the plain function `plain_key`.
+/// How a call whose arguments are already on the wasm stack is emitted.
+#[derive(Clone, Copy, PartialEq)]
+enum TailMode {
+    Plain,
+    /// `return_call` to a real wasm function / `return_call_indirect`.
+    Return,
+    /// Branch back to the fn body's loop (a self call).
+    Loop,
+}
+/// Whether the call in tail position (resolved to wasm fn `func_idx`, or `None` for a
+/// closure call) may skip the stack. Needs the callee's wasm result to equal the
+/// enclosing fn's with no conversion in between: the call's plum type must be the
+/// fn's declared return type.
+fn tailMode(
+    tail: ast::TailKind,
+    func_idx: Option<u32>,
+    callee_ret: &[ValType],
+    result_ty: &PlumType,
+    ctx: &LocalCtx,
+) -> TailMode {
+    if tail == ast::TailKind::NotTail {
+        return TailMode::Plain;
+    }
+    let Some(sf) = &ctx.self_func else {
+        return TailMode::Plain;
+    };
+    if sf.ret != callee_ret {
+        return TailMode::Plain;
+    }
+    let want = ctx.ret_type.clone().unwrap_or(PlumType::TUnit);
+    if matches!(want, PlumType::TErr(..)) || &want != result_ty {
+        return TailMode::Plain;
+    }
+    match func_idx {
+        Some(i) if i < ctx.import_count => TailMode::Plain,
+        Some(i) if i == sf.idx && sf.looped && tail == ast::TailKind::SelfCall => TailMode::Loop,
+        _ => TailMode::Return,
+    }
+}
+/// Emits the call to `func_idx` (arguments already pushed): a plain `call`, a
+/// `return_call`, or - for a self tail call - `local.set` of every param followed by
+/// a branch back to the fn body's loop.
+fn emitCall(
+    func_idx: u32,
+    sig: &FuncSig,
+    tail: ast::TailKind,
+    result_expr: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+) {
+    let ty = inferLocalType(result_expr, ctx);
+    match tailMode(tail, Some(func_idx), &sig.ret, &ty, ctx) {
+        TailMode::Plain => Instruction::Call(func_idx).encode(body),
+        TailMode::Return => Instruction::ReturnCall(func_idx).encode(body),
+        TailMode::Loop => {
+            // Every argument is already on the stack (so none reads a param after
+            // it is overwritten); assign them to the param locals in reverse.
+            for i in (0..sig.params.len() as u32).rev() {
+                Instruction::LocalSet(i).encode(body);
+            }
+            Instruction::Br(ctx.tail_depth.get()).encode(body);
+        }
+    }
+}
 fn resolveCallee<'c>(
     ctx: &'c LocalCtx,
     call_expr: &ast::Expr,
@@ -8102,11 +8147,7 @@ fn compileMethodCallAs(
             compileExpr(object, body, ctx, state)?;
         }
         compileCallArgs(&method, &call.args, sig, body, ctx, state)?;
-        if tailCallOk(result_expr, &sig.ret, ctx) {
+        emitCall(func_idx, sig, call.tail, result_expr, body, ctx);
-            Instruction::ReturnCall(func_idx).encode(body);
-        } else {
-            Instruction::Call(func_idx).encode(body);
-        }
         return Ok(());
     }
     let class_name = match plum_checker::methodReceiverName(obj_ty) {
@@ -8125,7 +8166,7 @@ fn compileMethodCallAs(
     if !ctx.func_ids.contains_key(&key) && ctx.locals.contains_key(&field_local) {
         compileFieldRead(object, &method, obj_ty, result_expr, body, ctx, state)?;
         Instruction::LocalSet(ctx.locals[&field_local]).encode(body);
-        return compileClosureCallArgs(&field_local, &call.args, body, ctx, state);
+        return compileClosureCallArgs(&field_local, &call.args, ast::TailKind::NotTail, body, ctx, state);
     }
     let func_idx = *ctx
         .func_ids
@@ -8156,11 +8197,7 @@ fn compileMethodCallAs(
         .get(&key)
         .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, method))?;
     compileCallArgs(&key, &call.args, sig, body, ctx, state)?;
-    if tailCallOk(result_expr, &sig.ret, ctx) {
+    emitCall(func_idx, sig, call.tail, result_expr, body, ctx);
-        Instruction::ReturnCall(func_idx).encode(body);
-    } else {
-        Instruction::Call(func_idx).encode(body);
-    }
     Ok(())
 }
@@ -8483,12 +8520,12 @@ fn compileClosureLiteral(
 /// table index (the `call_indirect` operand).
 fn compileClosureCall(
     call: &ast::FnCall,
-    call_expr: &ast::Expr,
+    _call_expr: &ast::Expr,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    compileClosureCallArgsTail(&call.name, &call.args, Some(call_expr), body, ctx, state)
+    compileClosureCallArgs(&call.name, &call.args, call.tail, body, ctx, state)
 }
 /// `compileClosureCall` over the local `name` with explicit `args` — the args must be
@@ -8497,19 +8534,7 @@ fn compileClosureCall(
 fn compileClosureCallArgs(
     name: &str,
     args: &[ast::Arg],
-    body: &mut Vec<u8>,
-    ctx: &LocalCtx,
+    tail: ast::TailKind,
-    state: &mut ModuleState,
-) -> Result<(), String> {
-    compileClosureCallArgsTail(name, args, None, body, ctx, state)
-}
-/// `compileClosureCallArgs`; with `tail_expr` (the call expression) it may emit
-/// `return_call_indirect` when the call is a valid tail call (see `tailCallOk`).
-fn compileClosureCallArgsTail(
-    name: &str,
-    args: &[ast::Arg],
-    tail_expr: Option<&ast::Expr>,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -8550,15 +8575,15 @@ fn compileClosureCallArgsTail(
         field_index: 0,
     }
     .encode(body);
-    let callee_ret: Vec<ValType> = withGcTypes(|g| flatValtypes(r, g));
+    let ret_vts = key.1.clone();
-    if tail_expr.is_some_and(|e| tailCallOk(e, &callee_ret, ctx)) {
+    if tailMode(tail, None, &ret_vts, r, ctx) == TailMode::Plain {
-        Instruction::ReturnCallIndirect {
+        Instruction::CallIndirect {
             type_index,
             table_index: 0,
         }
         .encode(body);
     } else {
-        Instruction::CallIndirect {
+        Instruction::ReturnCallIndirect {
             type_index,
             table_index: 0,
         }
@@ -8711,10 +8736,13 @@ fn compileClosureBody(
         gc_types: &ctx.gc_types,
         singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
-        loop_extra_depth: Cell::new(0),
+        loop_base_depth: Cell::new(0),
         ret_type: Some(info.ret_ptype.clone()),
         match_subject_types: RefCell::new(HashMap::new()),
         subject_ptypes: RefCell::new(HashMap::new()),
+        self_func: None,
+        tail_depth: Cell::new(0),
+        import_count: ctx.import_count,
     };
     if matches!(info.ret_ptype, PlumType::TUnit) {

plum-wasm-codegen/tests/tail_calls_e2e_test.rs ADDED Viewed

@@ -0,0 +1,283 @@
+#![allow(non_snake_case)]
+use plum_wasm_codegen::compileSource;
+fn tailEngine() -> wasmtime::Engine {
+    let mut config = wasmtime::Config::new();
+    config.wasm_gc(true);
+    config.wasm_function_references(true);
+    config.wasm_tail_call(true);
+    wasmtime::Engine::new(&config).expect("engine with GC and tail calls should construct")
+}
+fn repoRoot() -> std::path::PathBuf {
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..")
+}
+fn compile(name: &str, src: &str) -> Vec<u8> {
+    let dir = std::env::temp_dir().join(format!("plum_tail_calls_{}_{}", name, std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let r = plum_core::loadAndMerge(&path, &repoRoot());
+    let _ = std::fs::remove_dir_all(&dir);
+    let source = r.unwrap_or_else(|e| panic!("load: {e}"));
+    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed: {e}"));
+    let mut v = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures::all());
+    v.validate_all(&bytes).expect("valid wasm");
+    bytes
+}
+/// Compiles `src` through the real pipeline and runs its `main() -> Int`.
+fn runInt(name: &str, src: &str) -> i64 {
+    let bytes = compile(name, src);
+    let engine = tailEngine();
+    let module = wasmtime::Module::new(&engine, &bytes).unwrap();
+    let mut store = wasmtime::Store::new(&engine, ());
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker
+        .define_unknown_imports_as_default_values(&mut store, &module)
+        .unwrap();
+    let instance = linker.instantiate(&mut store, &module).unwrap();
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .unwrap();
+    main.call(&mut store, ()).unwrap()
+}
+const PRE: &str = "import std/Str\nimport std/Int\nimport std/Float\nimport std/List\n\n";
+fn prog(body: &str) -> String {
+    format!("{PRE}{body}")
+}
+const LINK: &str = "
+enum Link[T] = Nil | Cons(head: T, tail: Link[T])
+fun build(n: Int, acc: Link[Int]) -> Link[Int] =
+  if n == 0 then acc else build(n - 1, Cons(head: n, tail: acc))
+fun sumAcc(xs: Link[Int], acc: Int) -> Int = match xs
+  Nil => acc
+  Cons(h, t) => sumAcc(t, acc + h)
+";
+#[test]
+fn self_tail_million() {
+    let src = prog(&format!(
+        "{LINK}
+fun main() -> Int = sumAcc(build(1000000, Nil), 0)
+"
+    ));
+    assert_eq!(runInt("self_tail_million", &src), 500000500000);
+}
+#[test]
+fn self_tail_args_swap() {
+    let src = prog(
+        "fun gcd(a: Int, b: Int) -> Int = if b == 0 then a else gcd(b, a % b)
+fun swapN(a: Int, b: Int, n: Int) -> Int =
+  if n == 0 then a * 1000 + b else swapN(b, a, n - 1)
+fun main() -> Int = gcd(1071, 462) * 1000000 + swapN(1, 2, 999999)
+",
+    );
+    // gcd = 21; odd swap count leaves (2, 1).
+    assert_eq!(runInt("self_tail_args_swap", &src), 21 * 1000000 + 2001);
+}
+#[test]
+fn mutual_tail_million() {
+    let src = prog(
+        "fun isEven(n: Int) -> Int = if n == 0 then 1 else isOdd(n - 1)
+fun isOdd(n: Int) -> Int = if n == 0 then 0 else isEven(n - 1)
+fun main() -> Int = isEven(1000001) * 10 + isOdd(1000001)
+",
+    );
+    assert_eq!(runInt("mutual_tail_million", &src), 1);
+}
+#[test]
+fn closure_tail_call_runs() {
+    let src = prog(
+        "fun run(n: Int, k: fn(Int) -> Int) -> Int = if n == 0 then 7 else k(n - 1)
+fun go(n: Int) -> Int = run(n, go)
+fun main() -> Int = go(1000000)
+",
+    );
+    assert_eq!(runInt("closure_tail_call_runs", &src), 7);
+}
+#[test]
+fn method_self_tail() {
+    let src = prog(
+        "record Counter(step: Int) =
+  fun count(self, n: Int, acc: Int) -> Int =
+    if n == 0 then acc else self.count(n - 1, acc + self.step)
+fun main() -> Int = Counter(step: 3).count(1000000, 0)
+",
+    );
+    assert_eq!(runInt("method_self_tail", &src), 3000000);
+}
+#[test]
+fn own_param_self_tail() {
+    let src = prog(
+        "own record Cell(x: Int, y: Int)
+fun bump(own c: Cell, n: Int) -> Cell =
+  if n == 0 then c else bump(Cell(..c, x: c.x + 1), n - 1)
+fun main() -> Int =
+  c := bump(Cell(x: 0, y: 5), 100000)
+  c.x * 10 + c.y
+",
+    );
+    assert_eq!(runInt("own_param_self_tail", &src), 1000005);
+}
+/// R3: a closure made in one iteration keeps that iteration's parameter value.
+#[test]
+fn closure_captures_iteration_value() {
+    let src = prog(
+        "fun go(i: Int, f: fn(Int) -> Int) -> Int =
+  if i == 3 then f(100) else go(i + 1, |x| x + i)
+fun main() -> Int = go(0, |x| x)
+",
+    );
+    assert_eq!(runInt("closure_captures_iteration_value", &src), 102);
+}
+/// Match arms and else-if chains nest wasm blocks between the call and the loop.
+#[test]
+fn self_tail_through_nested_branches() {
+    let src = prog(
+        "fun f(n: Int, acc: Int) -> Int =
+  if n == 0 then acc
+  else if n % 3 == 0 then f(n - 1, acc + 1)
+  else if n % 3 == 1 then f(n - 1, acc + 10)
+  else f(n - 1, acc + 100)
+fun g(n: Int, acc: Int) -> Int = match n
+  0 => acc
+  k => if k % 2 == 0 then g(k - 1, acc + 2) else g(k - 1, acc + 1)
+fun main() -> Int = f(30, 0) * 1000 + g(10, 0)
+",
+    );
+    assert_eq!(runInt("self_tail_nested", &src), 1110 * 1000 + 15);
+}
+#[derive(Default)]
+struct FnOps {
+    calls: Vec<u32>,
+    branches: usize,
+    returnCalls: usize,
+    returnCallIndirects: usize,
+}
+/// Operator summary of the `n`-th function-section body whose export-or-name matches `pick`.
+fn opsOf(bytes: &[u8], pick: &str) -> FnOps {
+    // Find the function index by its name-section entry.
+    let mut importCount = 0u32;
+    let mut target: Option<u32> = None;
+    let mut bodies: Vec<wasmparser::FunctionBody> = Vec::new();
+    for payload in wasmparser::Parser::new(0).parse_all(bytes) {
+        match payload.unwrap() {
+            wasmparser::Payload::ImportSection(r) => {
+                for imp in r {
+                    if matches!(imp.unwrap().ty, wasmparser::TypeRef::Func(_)) {
+                        importCount += 1;
+                    }
+                }
+            }
+            wasmparser::Payload::CodeSectionEntry(f) => bodies.push(f),
+            wasmparser::Payload::CustomSection(c) => {
+                if let wasmparser::KnownCustom::Name(names) = c.as_known() {
+                    for n in names {
+                        if let Ok(wasmparser::Name::Function(map)) = n {
+                            for naming in map {
+                                let naming = naming.unwrap();
+                                if naming.name == pick {
+                                    target = Some(naming.index);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    let idx = target.unwrap_or_else(|| panic!("no function named {pick}"));
+    let body = &bodies[(idx - importCount) as usize];
+    let mut ops = FnOps::default();
+    let mut r = body.get_operators_reader().unwrap();
+    while !r.eof() {
+        match r.read().unwrap() {
+            wasmparser::Operator::Call { function_index } => ops.calls.push(function_index),
+            wasmparser::Operator::Br { .. } => ops.branches += 1,
+            wasmparser::Operator::ReturnCall { .. } => ops.returnCalls += 1,
+            wasmparser::Operator::ReturnCallIndirect { .. } => ops.returnCallIndirects += 1,
+            _ => {}
+        }
+    }
+    ops
+}
+fn funcIndexOf(bytes: &[u8], name: &str) -> u32 {
+    for payload in wasmparser::Parser::new(0).parse_all(bytes) {
+        if let wasmparser::Payload::CustomSection(c) = payload.unwrap() {
+            if let wasmparser::KnownCustom::Name(names) = c.as_known() {
+                for n in names {
+                    if let Ok(wasmparser::Name::Function(map)) = n {
+                        for naming in map {
+                            let naming = naming.unwrap();
+                            if naming.name == name {
+                                return naming.index;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    panic!("no function named {name}");
+}
+#[test]
+fn wasm_has_no_call_in_loop() {
+    let src = prog(&format!(
+        "{LINK}
+fun main() -> Int = sumAcc(build(10, Nil), 0)
+"
+    ));
+    let bytes = compile("wasm_has_no_call_in_loop", &src);
+    let me = funcIndexOf(&bytes, "sumAcc");
+    let ops = opsOf(&bytes, "sumAcc");
+    assert!(ops.branches >= 1, "sumAcc should branch back to its loop");
+    assert!(!ops.calls.contains(&me), "sumAcc must not call itself");
+    assert_eq!(ops.returnCalls, 0);
+}
+#[test]
+fn return_call_emitted() {
+    let src = prog(
+        "fun isEven(n: Int) -> Int = if n == 0 then 1 else isOdd(n - 1)
+fun isOdd(n: Int) -> Int = if n == 0 then 0 else isEven(n - 1)
+fun main() -> Int = isEven(10)
+",
+    );
+    let bytes = compile("return_call_emitted", &src);
+    let ops = opsOf(&bytes, "isEven");
+    assert!(ops.returnCalls >= 1, "isEven should return_call isOdd");
+    assert!(ops.calls.is_empty());
+}