elly_core/

code.rs

//! Code in static chunks: the flat form of one compile (see
//! `docs/done/2026-10-11_elly-ctx-chunks.md`).
//!
//! A [`StaticChunk`] holds a top module and the modules nested in it as flat
//! tables of small `Copy` entries, which refer to each other by `u32` ids. The
//! parser emits a chunk as it reads the Muon tree (`parse.rs`), and a chunk
//! renders as s-expressions for the parse goldens and as tagged JSON for the
//! playground.
//!
//! The tables are filled in post-order: emitting a node pushes its descendants
//! and returns its own node unpushed, and the parent pushes its children's
//! nodes as one run, then itself. Every operand then points below the entry
//! that holds it, which is what makes a chunk valid by construction. Module
//! entries are the exception: each is reserved when its walk starts and filled
//! when it ends, so a module's parent comes before it and the top module is
//! the first.
//!
//! In debug builds a barrier entry stands before each run and records its kind
//! and length, and the run accessors assert that it matches. Indices therefore
//! differ between debug and release builds.

use alloc::boxed::Box;
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use core::ops::Range;

use num_bigint::BigInt;

use crate::builtins::{TyKind, MODULES};
use crate::module::{ImportSpec, ModuleName};
use crate::source::{ChunkLocs, ChunkSpan, DocSource, DocsBuilder, Loc, Pos};
use crate::{Builtin, Ctx, Sym};

/// An owned, cheap-clone text leaf using hipstr's `Local` (`Rc`) backend.
/// Short strings (≤ 23 bytes on 64-bit) are inlined; longer strings use a shared
/// `Rc<str>` slice. This keeps chunks and `Value` `'static` and independent of
/// the Muon source.
pub type Text = hipstr::LocalHipStr<'static>;

/// One compile, flat and immutable: see the [module documentation](self).
#[derive(Debug)]
pub struct StaticChunk {
    /// The loaded module's name, `Elly` for the builtins, or a name the realm
    /// made: `__eval_N` for an expression, `__module_N` for an unnamed module.
    name: Text,
    nodes: Box<[Node]>,
    pats: Box<[Pat]>,
    lambdas: Box<[Lambda]>,
    captures: Box<[Capture]>,
    modules: Box<[Module]>,
    members: Box<[Member]>,
    frame: Box<[Sym]>,
    imports: Box<[ImportSpec]>,
    ints: Box<[BigInt]>,
    strs: Box<[Text]>,
    /// Where the code came from, out of line: only errors and tools read it.
    pub(crate) locs: Box<ChunkLocs>,
}

/// An expression: a tag and up to three `u32` operands, 16 bytes. Children are
/// ids into the same chunk; a node with many children names a run.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Node {
    /// An integer that fits in `i64`.
    Int(i64),
    /// Any other integer, in the chunk's `ints` table.
    BigInt(IntId),
    Unit,
    /// A dotted symbol, stored without the dot.
    Symbol(Sym),
    Str(StrId),
    /// A resolved local; `name` is kept for rendering.
    Local {
        name: Sym,
        index: u32,
    },
    Builtin(Builtin),
    /// A member of an enclosing module: `index` into its member space, past
    /// `depth` module terminals.
    ModItem {
        index: u32,
        depth: u32,
        name: Sym,
    },
    Home {
        leaf: HomeLeaf,
        depth: u32,
    },
    /// The run is the callee, then the `len - 1` arguments.
    App {
        len: u32,
        args: NodeId,
    },
    List {
        len: u32,
        elems: NodeId,
    },
    /// The run is the `len` keys, then the `len` values.
    Map {
        len: u32,
        entries: NodeId,
    },
    /// `len` patterns from `binds` ([`Pat::None`] for a clause that binds
    /// nothing) and `len` clause expressions from `exprs`.
    Block {
        len: u32,
        binds: PatId,
        exprs: NodeId,
    },
    /// `len` patterns from `conds`, and from `exprs` the `len` arm bodies
    /// followed by the subject.
    Case {
        len: u32,
        conds: PatId,
        exprs: NodeId,
    },
    Abs(LambdaId),
    /// A `recur` group: a nested module with items and a body.
    Recur(ModId),
    /// Stands before a run in debug builds.
    #[cfg(debug_assertions)]
    Barrier {
        run: Run,
        len: u32,
    },
}

/// A pattern, 16 bytes like [`Node`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Pat {
    /// The slot of a block clause that binds nothing.
    None,
    Discard,
    Unit,
    Bind(Sym),
    At(Sym, PatId),
    Equal(NodeId),
    Less(NodeId),
    Greater(NodeId),
    /// `<pat> as <Kind>`, a builtin prototype.
    TypeKind(TyKind, PatId),
    /// `<pat> as <Proto>`, any other prototype, evaluated at match time.
    TypeRef(NodeId, PatId),
    Unwrap {
        depth: u32,
        inner: PatId,
    },
    Or(PatId, PatId),
    /// `rest` is [`PatId::NONE`] for an exact-length list.
    List {
        len: u32,
        elems: PatId,
        rest: PatId,
    },
    /// The run is the `len` key patterns, then the `len` value patterns. A key
    /// is a [`Lookup`](Pat::Lookup) or a pattern that captures the key.
    Map {
        len: u32,
        entries: PatId,
        rest: PatId,
    },
    /// A map pattern's looked-up key.
    Lookup(NodeId),
    /// `gpat` is [`PatId::NONE`] for a plain guard.
    When {
        inner: PatId,
        gpat: PatId,
        cond: NodeId,
    },
    /// Stands before a run in debug builds.
    #[cfg(debug_assertions)]
    Barrier {
        run: Run,
        len: u32,
    },
}

/// The code of an abstraction. Its arity is `head.len`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Lambda {
    pub head: IdRange<PatId>,
    pub body: NodeId,
    pub captures: Plan,
}

/// A module of the chunk: the top module, or a nested one.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Module {
    /// The canonical name the host gave it, if any.
    pub name: Option<ModuleName>,
    /// The enclosing module, [`ModId::NONE`] for the top module.
    pub parent: ModId,
    /// The member index space: the items, then the locals, then the iotas,
    /// each sorted by `Sym`.
    pub members: IdRange<MemberId>,
    /// How many of `members` are items; the locals follow them.
    pub items: u32,
    /// How many of `members` are locals; the iotas follow them.
    pub locals: u32,
    /// The names of the frame slots, imports first.
    pub frame: IdRange<FrameId>,
    /// The specs of the leading frame slots.
    pub imports: IdRange<ImportId>,
    /// A `recur` group's body or a source's `__main`, or [`NodeId::NONE`].
    pub body: NodeId,
}

/// A module member. An iota has no body: its `node` is [`NodeId::NONE`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Member {
    pub name: Sym,
    pub node: NodeId,
}

/// Home-module leaf types: the module itself (`Self`), construction
/// (`#Self(…)`), or payload read (`x.Self`). These share the same resolution
/// machinery (one walk to the terminal) and differ only in their eval result.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HomeLeaf {
    /// `Self` — the home module as a `Value::Module`.
    Module,
    /// `#Self(…)` / `#Self …` — the object constructor for the home module.
    /// Always the callee of an [`App`](Node::App). Renders as `(new …)`.
    New,
    /// `x.Self` — the payload reader for the home module. Always the callee
    /// of an [`App`](Node::App). In patterns, spelled as [`Pat::Unwrap`].
    Value,
}

impl HomeLeaf {
    /// The name reported by the resolver for leaves outside a module body.
    pub fn name(self) -> &'static str {
        "Self"
    }
}

/// A captured free variable: `outer` is the de Bruijn index in the enclosing
/// activation at evaluation; `slot` is its position in the closure's frame.
/// The plan is sorted by `outer` so the evaluator fills the frame in one
/// linear walk of the environment.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Capture {
    pub outer: u32,
    pub slot: u32,
}

/// An index into one of a chunk's tables (or, for [`ChunkId`], the realm's).
pub trait Id: Copy {
    /// The position in the table.
    fn index(self) -> usize;
    /// The id of position `index`.
    fn at(index: usize) -> Self;
}

macro_rules! ids {
    ($($(#[$doc:meta])* $name:ident;)*) => {$(
        $(#[$doc])*
        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        pub struct $name(u32);

        impl $name {
            /// No entry: an absent operand.
            pub const NONE: Self = Self(u32::MAX);

            /// The id, or `None` for [`NONE`](Self::NONE).
            pub fn get(self) -> Option<Self> {
                (self != Self::NONE).then_some(self)
            }

            /// The id `i` entries further on: entry `i` of a run that starts here.
            #[inline]
            pub fn nth(self, i: u32) -> Self {
                Self(self.0 + i)
            }
        }

        impl Id for $name {
            fn index(self) -> usize {
                self.0 as usize
            }

            fn at(index: usize) -> Self {
                assert!(index < u32::MAX as usize, "a chunk table outgrew u32");
                Self(index as u32)
            }
        }
    )*};
}

ids! {
    /// A chunk in its realm's table.
    ChunkId;
    /// An expression node.
    NodeId;
    /// A pattern.
    PatId;
    /// A lambda's head, body and capture plan.
    LambdaId;
    /// A module: the top module, or a nested one such as a `recur` group.
    ModId;
    /// A module member: an item, a local or an iota.
    MemberId;
    /// One entry of a lambda's capture plan.
    CaptureId;
    /// A big integer literal.
    IntId;
    /// A string literal.
    StrId;
    /// A frame slot's name.
    FrameId;
    /// An import's spec.
    ImportId;
}

impl ChunkId {
    /// The builtin modules, built by every realm first (see
    /// [`Ctx::builtin_module`](crate::Ctx)).
    pub const ELLY: ChunkId = ChunkId(0);
}

impl ModId {
    /// The builtin module in cache slot `slot` of the [`ELLY`](ChunkId::ELLY)
    /// chunk, whose top module holds nothing.
    pub(crate) fn builtin(slot: usize) -> ModId {
        ModId::at(slot + 1)
    }
}

/// `len` entries of one table, starting at `first`. An empty range starts at
/// the table's length when it was made.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct IdRange<I> {
    pub first: I,
    pub len: u32,
}

impl<I: Id> IdRange<I> {
    fn indices(self) -> Range<usize> {
        let first = self.first.index();
        first..first + self.len as usize
    }
}

/// What a run of nodes or patterns belongs to, recorded by its barrier in
/// debug builds.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Run {
    /// An application: the callee, then the arguments.
    App,
    /// A list literal's elements.
    List,
    /// A map literal's keys, then its values.
    Map,
    /// A block's binding patterns, or its clause expressions.
    Block,
    /// A case's arm patterns, or its arm bodies followed by the subject.
    Case,
    /// A lambda's parameter patterns.
    Head,
    /// A list pattern's elements.
    PatList,
    /// A map pattern's key patterns, then its value patterns.
    PatMap,
}

/// How a closure captures its environment.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Plan {
    /// Share the defining environment by reference. Used when the closure
    /// is applied where it is made (a direct application, a builtin's thunk
    /// argument), avoiding frame allocation.
    Chain,
    /// Copy the free variables into a fresh frame, the default for escaping
    /// closures. An empty plan is a closed lambda.
    Frame(IdRange<CaptureId>),
}

impl StaticChunk {
    /// The chunk's name.
    pub fn name(&self) -> &Text {
        &self.name
    }

    /// The top module, the chunk's first.
    pub fn top(&self) -> ModId {
        ModId(0)
    }

    pub fn node(&self, id: NodeId) -> Node {
        self.nodes[id.index()]
    }

    pub fn pat(&self, id: PatId) -> Pat {
        self.pats[id.index()]
    }

    pub fn lambda(&self, id: LambdaId) -> &Lambda {
        &self.lambdas[id.index()]
    }

    pub fn module(&self, id: ModId) -> &Module {
        &self.modules[id.index()]
    }

    /// A module's member index space (see [`Module::members`]).
    pub fn members(&self, module: &Module) -> &[Member] {
        &self.members[module.members.indices()]
    }

    /// A module's frame slot names.
    pub fn frame_names(&self, module: &Module) -> &[Sym] {
        &self.frame[module.frame.indices()]
    }

    /// A module's import specs.
    pub fn imports(&self, module: &Module) -> &[ImportSpec] {
        &self.imports[module.imports.indices()]
    }

    /// A lambda's frame plan.
    pub fn captures(&self, plan: IdRange<CaptureId>) -> &[Capture] {
        &self.captures[plan.indices()]
    }

    pub fn int(&self, id: IntId) -> &BigInt {
        &self.ints[id.index()]
    }

    pub fn str(&self, id: StrId) -> &Text {
        &self.strs[id.index()]
    }

    /// The `len` nodes of a run of kind `run`, starting at `first`.
    pub fn nodes(&self, run: Run, first: NodeId, len: u32) -> &[Node] {
        let first = first.index();
        #[cfg(debug_assertions)]
        assert_eq!(
            self.nodes[first - 1],
            Node::Barrier { run, len },
            "a run of nodes does not match its barrier"
        );
        let _ = run;
        &self.nodes[first..first + len as usize]
    }

    /// The `len` patterns of a run of kind `run`, starting at `first`.
    pub fn pats(&self, run: Run, first: PatId, len: u32) -> &[Pat] {
        let first = first.index();
        #[cfg(debug_assertions)]
        assert_eq!(
            self.pats[first - 1],
            Pat::Barrier { run, len },
            "a run of patterns does not match its barrier"
        );
        let _ = run;
        &self.pats[first..first + len as usize]
    }

    /// The ids of the chunk's modules, the top module first.
    pub fn module_ids(&self) -> impl Iterator<Item = ModId> + Clone {
        (0..self.modules.len()).map(ModId::at)
    }

    /// The item or local at `index` of module `m`'s member space, or `None`
    /// past them, where the iotas are.
    #[inline]
    pub fn member(&self, m: ModId, index: u32) -> Option<Member> {
        let module = self.module(m);
        if index >= module.items + module.locals {
            return None;
        }
        Some(self.members[module.members.first.index() + index as usize])
    }

    /// How many items and locals module `m` has: the size of its id block,
    /// and where its iotas start.
    pub fn member_len(&self, m: ModId) -> u32 {
        let module = self.module(m);
        module.items + module.locals
    }

    /// The name of iota `index` of module `m`, counted from its first iota.
    pub fn iota(&self, m: ModId, index: u32) -> Option<Sym> {
        let module = self.module(m);
        let iotas = &self.members(module)[(module.items + module.locals) as usize..];
        iotas.get(index as usize).map(|member| member.name)
    }

    /// The index of module `m`'s item `name`, searched by `Sym`. Locals are
    /// not searched: they are private.
    pub fn index_of(&self, m: ModId, name: Sym) -> Option<u32> {
        let module = self.module(m);
        self.members(module)[..module.items as usize]
            .binary_search_by(|member| member.name.cmp(&name))
            .ok()
            .map(|i| i as u32)
    }

    /// Module `m`'s item names, sorted by `Sym`: its public listing.
    pub fn item_names(&self, m: ModId) -> impl Iterator<Item = Sym> + '_ {
        let module = self.module(m);
        self.members(module)[..module.items as usize]
            .iter()
            .map(|member| member.name)
    }

    /// Module `m`'s `local` names, sorted by `Sym`. Locals are unreachable
    /// as `M.name` from outside; this is for host introspection.
    pub fn local_names(&self, m: ModId) -> impl Iterator<Item = Sym> + '_ {
        let module = self.module(m);
        let start = module.items as usize;
        self.members(module)[start..start + module.locals as usize]
            .iter()
            .map(|member| member.name)
    }

    /// Module `m`'s iota names, sorted by `Sym`.
    pub fn iota_names(&self, m: ModId) -> impl Iterator<Item = Sym> + '_ {
        let module = self.module(m);
        self.members(module)[(module.items + module.locals) as usize..]
            .iter()
            .map(|member| member.name)
    }
}

// ---------------------------------------------------------------------------
// The builder
// ---------------------------------------------------------------------------

/// Builds one chunk. Nothing sees the chunk before [`finish`](Self::finish),
/// so a partly filled module entry is the builder's affair.
pub(crate) struct Builder {
    nodes: Vec<Node>,
    pats: Vec<Pat>,
    lambdas: Vec<Lambda>,
    captures: Vec<Capture>,
    modules: Vec<Module>,
    members: Vec<Member>,
    frame: Vec<Sym>,
    imports: Vec<ImportSpec>,
    ints: Vec<BigInt>,
    strs: Vec<Text>,
    node_spans: Vec<ChunkSpan>,
    pat_spans: Vec<ChunkSpan>,
    lambda_spans: Vec<ChunkSpan>,
    member_spans: Vec<ChunkSpan>,
    pub(crate) docs: DocsBuilder,
    /// Children's nodes and their spans waiting to be pushed as one run; each
    /// emitter pushes above a mark and drains back down to it.
    pub(crate) scratch: Vec<(Node, ChunkSpan)>,
    /// The same for patterns.
    pub(crate) pat_scratch: Vec<(Pat, ChunkSpan)>,
    /// The same for the members of the modules being emitted.
    pub(crate) member_scratch: Vec<(Member, ChunkSpan)>,
    /// The module whose bodies are being emitted, the parent of a nested one.
    current: ModId,
}

pub(crate) fn len32(len: usize) -> u32 {
    u32::try_from(len).expect("a run outgrew u32")
}

impl Builder {
    pub(crate) fn new() -> Self {
        Builder {
            nodes: Vec::new(),
            pats: Vec::new(),
            lambdas: Vec::new(),
            captures: Vec::new(),
            modules: Vec::new(),
            members: Vec::new(),
            frame: Vec::new(),
            imports: Vec::new(),
            ints: Vec::new(),
            strs: Vec::new(),
            node_spans: Vec::new(),
            pat_spans: Vec::new(),
            lambda_spans: Vec::new(),
            member_spans: Vec::new(),
            docs: DocsBuilder::default(),
            scratch: Vec::new(),
            pat_scratch: Vec::new(),
            member_scratch: Vec::new(),
            current: ModId::NONE,
        }
    }

    /// The chunk, named `name`, its anonymous document numbered `made`.
    pub(crate) fn finish(self, name: Text, made: Option<u32>) -> StaticChunk {
        debug_assert!(self.scratch.is_empty() && self.pat_scratch.is_empty());
        debug_assert!(self.member_scratch.is_empty());
        debug_assert!(!self.modules.is_empty(), "a chunk has a top module");
        let (docs, line_starts) = self.docs.finish(made);
        StaticChunk {
            name,
            nodes: self.nodes.into_boxed_slice(),
            pats: self.pats.into_boxed_slice(),
            lambdas: self.lambdas.into_boxed_slice(),
            captures: self.captures.into_boxed_slice(),
            modules: self.modules.into_boxed_slice(),
            members: self.members.into_boxed_slice(),
            frame: self.frame.into_boxed_slice(),
            imports: self.imports.into_boxed_slice(),
            ints: self.ints.into_boxed_slice(),
            strs: self.strs.into_boxed_slice(),
            locs: Box::new(ChunkLocs {
                node_spans: self.node_spans.into_boxed_slice(),
                pat_spans: self.pat_spans.into_boxed_slice(),
                lambda_spans: self.lambda_spans.into_boxed_slice(),
                member_spans: self.member_spans.into_boxed_slice(),
                docs,
                line_starts,
                base: Loc::NONE,
            }),
        }
    }

    /// Records the document `text` from `source`, `None` for an anonymous
    /// one, and returns its first position in the chunk.
    pub(crate) fn add_doc(&mut self, source: Option<DocSource>, text: &str) -> Pos {
        self.docs.add(source, text)
    }

    pub(crate) fn push(&mut self, node: Node, span: ChunkSpan) -> NodeId {
        let id = NodeId::at(self.nodes.len());
        self.nodes.push(node);
        self.node_spans.push(span);
        id
    }

    pub(crate) fn push_pat(&mut self, pat: Pat, span: ChunkSpan) -> PatId {
        let id = PatId::at(self.pats.len());
        self.pats.push(pat);
        self.pat_spans.push(span);
        id
    }

    /// The node `id`, already pushed, and its span.
    pub(crate) fn node(&self, id: NodeId) -> (Node, ChunkSpan) {
        (self.nodes[id.index()], self.node_spans[id.index()])
    }

    /// Pushes `scratch[mark..]` as one run, behind a barrier in debug builds.
    pub(crate) fn push_run(&mut self, run: Run, mark: usize) -> NodeId {
        #[cfg(debug_assertions)]
        {
            let len = len32(self.scratch.len() - mark);
            self.push(Node::Barrier { run, len }, ChunkSpan::NONE);
        }
        let _ = run;
        let first = NodeId::at(self.nodes.len());
        for (node, span) in self.scratch.drain(mark..) {
            self.nodes.push(node);
            self.node_spans.push(span);
        }
        first
    }

    /// Pushes `pat_scratch[mark..]` as one run, behind a barrier in debug builds.
    pub(crate) fn push_pat_run(&mut self, run: Run, mark: usize) -> PatId {
        #[cfg(debug_assertions)]
        {
            let len = len32(self.pat_scratch.len() - mark);
            self.push_pat(Pat::Barrier { run, len }, ChunkSpan::NONE);
        }
        let _ = run;
        let first = PatId::at(self.pats.len());
        for (pat, span) in self.pat_scratch.drain(mark..) {
            self.pats.push(pat);
            self.pat_spans.push(span);
        }
        first
    }

    /// An integer literal: inline if it fits `i64`, else in the `ints` table.
    pub(crate) fn int(&mut self, n: BigInt) -> Node {
        match i64::try_from(&n) {
            Ok(n) => Node::Int(n),
            Err(_) => {
                let id = IntId::at(self.ints.len());
                self.ints.push(n);
                Node::BigInt(id)
            }
        }
    }

    /// A string literal, in the `strs` table.
    pub(crate) fn str(&mut self, s: Text) -> Node {
        let id = StrId::at(self.strs.len());
        self.strs.push(s);
        Node::Str(id)
    }

    /// A lambda whose head is `pat_scratch[mark..]` and whose body is `body`,
    /// capturing by `plan`: `None` for [`Plan::Chain`], else the frame plan.
    /// The lambda's span is `span`, its whole `&`.
    pub(crate) fn lambda(
        &mut self,
        mark: usize,
        body: (Node, ChunkSpan),
        plan: Option<&[Capture]>,
        span: ChunkSpan,
    ) -> Node {
        let len = self.pat_scratch.len() - mark;
        // A closure counts its applied arguments in a `u8`.
        assert!(
            len <= u8::MAX as usize,
            "a lambda has at most 255 parameters"
        );
        let head = IdRange {
            first: self.push_pat_run(Run::Head, mark),
            len: len32(len),
        };
        let body = self.push(body.0, body.1);
        let captures = match plan {
            None => Plan::Chain,
            Some(plan) => {
                let first = CaptureId::at(self.captures.len());
                self.captures.extend_from_slice(plan);
                Plan::Frame(IdRange {
                    first,
                    len: len32(plan.len()),
                })
            }
        };
        let id = LambdaId::at(self.lambdas.len());
        self.lambdas.push(Lambda {
            head,
            body,
            captures,
        });
        self.lambda_spans.push(span);
        Node::Abs(id)
    }

    /// Reserves the next module entry, with the current module as its parent,
    /// and makes it current. Its fields are filled when its walk ends.
    pub(crate) fn enter_module(&mut self) -> ModId {
        let id = ModId::at(self.modules.len());
        self.modules.push(Module {
            name: None,
            parent: self.current,
            members: IdRange {
                first: MemberId::NONE,
                len: 0,
            },
            items: 0,
            locals: 0,
            frame: IdRange {
                first: FrameId::NONE,
                len: 0,
            },
            imports: IdRange {
                first: ImportId::NONE,
                len: 0,
            },
            body: NodeId::NONE,
        });
        self.current = id;
        id
    }

    /// Fills the entry `id`, reserved by [`enter_module`](Self::enter_module),
    /// and makes its parent current again. Its members are
    /// `member_scratch[mark..]`: `items` items, then `locals` locals, then the
    /// iotas.
    #[allow(clippy::too_many_arguments)]
    pub(crate) fn leave_module(
        &mut self,
        id: ModId,
        name: Option<ModuleName>,
        mark: usize,
        items: u32,
        locals: u32,
        frame: &[Sym],
        imports: Vec<ImportSpec>,
        body: NodeId,
    ) {
        let members = IdRange {
            first: MemberId::at(self.members.len()),
            len: len32(self.member_scratch.len() - mark),
        };
        for (member, span) in self.member_scratch.drain(mark..) {
            self.members.push(member);
            self.member_spans.push(span);
        }
        let frame_range = IdRange {
            first: FrameId::at(self.frame.len()),
            len: len32(frame.len()),
        };
        self.frame.extend_from_slice(frame);
        let imports_range = IdRange {
            first: ImportId::at(self.imports.len()),
            len: len32(imports.len()),
        };
        self.imports.extend(imports);
        let parent = self.modules[id.index()].parent;
        self.modules[id.index()] = Module {
            name,
            parent,
            members,
            items,
            locals,
            frame: frame_range,
            imports: imports_range,
            body,
        };
        self.current = parent;
    }

    /// The builtin modules: an empty top module, and under it one module per
    /// cache slot, whose items are builtin leaves.
    pub(crate) fn builtin_modules(&mut self) {
        let top = self.enter_module();
        for (slot, (op, _, items, iotas)) in MODULES.iter().enumerate() {
            let id = self.enter_module();
            debug_assert_eq!(id, ModId::builtin(slot));
            let mark = self.member_scratch.len();
            for (name, op) in items.iter() {
                let node = self.push(Node::Builtin(*op), ChunkSpan::NONE);
                let member = Member { name: *name, node };
                self.member_scratch.push((member, ChunkSpan::NONE));
            }
            for name in iotas.iter() {
                let member = Member {
                    name: *name,
                    node: NodeId::NONE,
                };
                self.member_scratch.push((member, ChunkSpan::NONE));
            }
            // A builtin module is named after itself, so `__Mod.name __Int`
            // answers `"__Int"`.
            let name = Some(Text::from_static(op.name()));
            let items = len32(items.len());
            self.leave_module(id, name, mark, items, 0, &[], Vec::new(), NodeId::NONE);
        }
        let mark = self.member_scratch.len();
        self.leave_module(top, None, mark, 0, 0, &[], Vec::new(), NodeId::NONE);
    }
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

impl StaticChunk {
    /// The s-expression of node `id`, e.g. `(app (name f) (name x))`.
    pub fn to_sexp(&self, id: NodeId, ctx: &Ctx) -> String {
        let mut out = String::new();
        self.write_sexp(self.node(id), &mut out, ctx);
        out
    }

    fn write_sexp(&self, node: Node, out: &mut String, ctx: &Ctx) {
        match node {
            Node::Int(n) => {
                out.push_str("(int ");
                out.push_str(&n.to_string());
                out.push(')');
            }
            Node::BigInt(id) => {
                out.push_str("(int ");
                out.push_str(&self.int(id).to_string());
                out.push(')');
            }
            Node::Local { name, .. } => {
                out.push_str("(name ");
                push_sym(name, out, ctx);
                out.push(')');
            }
            Node::Builtin(op) => {
                out.push_str("(name ");
                out.push_str(op.name());
                out.push(')');
            }
            Node::Home { leaf, .. } => match leaf {
                HomeLeaf::Module => out.push_str("(self)"),
                HomeLeaf::New => out.push_str("(new)"),
                HomeLeaf::Value => out.push_str("(value)"),
            },
            Node::ModItem { name, .. } => {
                out.push_str("(moditem ");
                push_sym(name, out, ctx);
                out.push(')');
            }
            // `(recur (bind a …) (bind b …) <body>)`, the bindings in text order.
            Node::Recur(id) => {
                let module = self.module(id);
                out.push_str("(recur");
                for member in self.items_by_text(module, ctx) {
                    out.push_str(" (bind ");
                    push_sym(member.name, out, ctx);
                    out.push(' ');
                    self.write_sexp(self.node(member.node), out, ctx);
                    out.push(')');
                }
                out.push(' ');
                self.write_sexp(self.node(module.body), out, ctx);
                out.push(')');
            }
            Node::Symbol(s) => {
                out.push_str("(sym .");
                push_sym(s, out, ctx);
                out.push(')');
            }
            Node::Str(id) => json_str(self.str(id), out),
            Node::App { len, args } => {
                let items = self.nodes(Run::App, args, len);
                let (open, body) = match items[0] {
                    Node::Home {
                        leaf: HomeLeaf::New,
                        ..
                    } => ("(new", &items[1..]),
                    Node::Home {
                        leaf: HomeLeaf::Value,
                        ..
                    } => ("(value", &items[1..]),
                    _ => ("(app", items),
                };
                out.push_str(open);
                for &item in body {
                    out.push(' ');
                    self.write_sexp(item, out, ctx);
                }
                out.push(')');
            }
            Node::Abs(id) => {
                let code = self.lambda(id);
                let head = self.pats(Run::Head, code.head.first, code.head.len);
                self.write_abs_sexp(head, code.body, out, ctx);
            }
            Node::Unit => out.push_str("(unit)"),
            Node::List { len, elems } => {
                out.push_str("(list");
                for &elem in self.nodes(Run::List, elems, len) {
                    out.push(' ');
                    self.write_sexp(elem, out, ctx);
                }
                out.push(')');
            }
            Node::Map { len, entries } => {
                let all = self.nodes(Run::Map, entries, 2 * len);
                let (keys, values) = all.split_at(len as usize);
                out.push_str("(map");
                for (&key, &value) in keys.iter().zip(values) {
                    out.push_str(" (entry ");
                    self.write_sexp(key, out, ctx);
                    out.push(' ');
                    self.write_sexp(value, out, ctx);
                    out.push(')');
                }
                out.push(')');
            }
            Node::Block { len, binds, exprs } => {
                let binds = self.pats(Run::Block, binds, len);
                let exprs = self.nodes(Run::Block, exprs, len);
                out.push_str("(block");
                for (&pat, &expr) in binds.iter().zip(exprs) {
                    out.push(' ');
                    if pat == Pat::None {
                        self.write_sexp(expr, out, ctx);
                    } else {
                        out.push_str("(bind ");
                        self.write_pat_sexp(pat, out, ctx);
                        out.push(' ');
                        self.write_sexp(expr, out, ctx);
                        out.push(')');
                    }
                }
                out.push(')');
            }
            Node::Case { len, conds, exprs } => {
                let conds = self.pats(Run::Case, conds, len);
                let exprs = self.nodes(Run::Case, exprs, len + 1);
                let (bodies, subject) = exprs.split_at(len as usize);
                out.push_str("(case ");
                self.write_sexp(subject[0], out, ctx);
                for (&pat, &body) in conds.iter().zip(bodies) {
                    out.push_str(" (arm ");
                    self.write_pat_sexp(pat, out, ctx);
                    out.push(' ');
                    self.write_sexp(body, out, ctx);
                    out.push(')');
                }
                out.push(')');
            }
            #[cfg(debug_assertions)]
            Node::Barrier { .. } => unreachable!("a barrier is not an operand"),
        }
    }

    /// A head `[p0, p1, …]` over `body` as nested `(abs p0 (abs p1 body))`.
    fn write_abs_sexp(&self, head: &[Pat], body: NodeId, out: &mut String, ctx: &Ctx) {
        out.push_str("(abs ");
        self.write_pat_sexp(head[0], out, ctx);
        out.push(' ');
        if head.len() == 1 {
            self.write_sexp(self.node(body), out, ctx);
        } else {
            self.write_abs_sexp(&head[1..], body, out, ctx);
        }
        out.push(')');
    }

    fn write_pat_sexp(&self, pat: Pat, out: &mut String, ctx: &Ctx) {
        match pat {
            Pat::None => unreachable!("only a block clause's slot binds nothing"),
            Pat::Discard => out.push('_'),
            Pat::Unit => out.push_str("(unit)"),
            Pat::Bind(name) => push_sym(name, out, ctx),
            Pat::At(name, inner) => {
                out.push_str("(at ");
                push_sym(name, out, ctx);
                out.push(' ');
                self.write_pat_sexp(self.pat(inner), out, ctx);
                out.push(')');
            }
            Pat::Equal(expr) => self.write_tagged_node("(eq ", expr, out, ctx),
            Pat::Less(expr) => self.write_tagged_node("(lt ", expr, out, ctx),
            Pat::Greater(expr) => self.write_tagged_node("(gt ", expr, out, ctx),
            Pat::TypeKind(kind, inner) => {
                out.push_str("(as ");
                out.push_str(kind.name());
                out.push(' ');
                self.write_pat_sexp(self.pat(inner), out, ctx);
                out.push(')');
            }
            Pat::TypeRef(proto, inner) => {
                out.push_str("(as ");
                self.write_sexp(self.node(proto), out, ctx);
                out.push(' ');
                self.write_pat_sexp(self.pat(inner), out, ctx);
                out.push(')');
            }
            Pat::Unwrap { inner, .. } => {
                out.push_str("(unwrap ");
                self.write_pat_sexp(self.pat(inner), out, ctx);
                out.push(')');
            }
            Pat::Or(left, right) => {
                out.push_str("(or ");
                self.write_pat_sexp(self.pat(left), out, ctx);
                out.push(' ');
                self.write_pat_sexp(self.pat(right), out, ctx);
                out.push(')');
            }
            Pat::List { len, elems, rest } => {
                out.push_str("(list");
                for &elem in self.pats(Run::PatList, elems, len) {
                    out.push(' ');
                    self.write_pat_sexp(elem, out, ctx);
                }
                self.write_rest_sexp(rest, out, ctx);
                out.push(')');
            }
            Pat::Map { len, entries, rest } => {
                let all = self.pats(Run::PatMap, entries, 2 * len);
                let (keys, values) = all.split_at(len as usize);
                out.push_str("(map");
                for (&key, &value) in keys.iter().zip(values) {
                    out.push_str(" (entry ");
                    match key {
                        Pat::Lookup(expr) => self.write_sexp(self.node(expr), out, ctx),
                        key => {
                            out.push_str("(capture ");
                            self.write_pat_sexp(key, out, ctx);
                            out.push(')');
                        }
                    }
                    out.push(' ');
                    self.write_pat_sexp(value, out, ctx);
                    out.push(')');
                }
                self.write_rest_sexp(rest, out, ctx);
                out.push(')');
            }
            Pat::Lookup(_) => unreachable!("a lookup is only a map pattern's key"),
            // `(when <inner> <cond>)`, or `(when <inner> (bind <gpat> <cond>))`.
            Pat::When { inner, gpat, cond } => {
                out.push_str("(when ");
                self.write_pat_sexp(self.pat(inner), out, ctx);
                out.push(' ');
                match gpat.get() {
                    None => self.write_sexp(self.node(cond), out, ctx),
                    Some(gpat) => {
                        out.push_str("(bind ");
                        self.write_pat_sexp(self.pat(gpat), out, ctx);
                        out.push(' ');
                        self.write_sexp(self.node(cond), out, ctx);
                        out.push(')');
                    }
                }
                out.push(')');
            }
            #[cfg(debug_assertions)]
            Pat::Barrier { .. } => unreachable!("a barrier is not an operand"),
        }
    }

    fn write_tagged_node(&self, open: &str, expr: NodeId, out: &mut String, ctx: &Ctx) {
        out.push_str(open);
        self.write_sexp(self.node(expr), out, ctx);
        out.push(')');
    }

    /// ` ...` and the rest pattern unless it is `_`; nothing for an exact one.
    fn write_rest_sexp(&self, rest: PatId, out: &mut String, ctx: &Ctx) {
        if let Some(rest) = rest.get() {
            out.push_str(" ...");
            let rest = self.pat(rest);
            if rest != Pat::Discard {
                self.write_pat_sexp(rest, out, ctx);
            }
        }
    }
}

impl StaticChunk {
    /// The tagged JSON of node `id`, e.g. `{"app":[{"name":"f"},{"name":"x"}]}`.
    pub fn to_json(&self, id: NodeId, ctx: &Ctx) -> String {
        let mut out = String::new();
        self.write_json(self.node(id), &mut out, ctx);
        out
    }

    fn write_json(&self, node: Node, out: &mut String, ctx: &Ctx) {
        match node {
            // A bare number if it fits in f64 [-2^53, 2^53] exactly; otherwise
            // a tagged decimal string to avoid precision loss.
            Node::Int(n) if (-(1 << 53)..=(1 << 53)).contains(&n) => {
                out.push_str(&n.to_string());
            }
            Node::Int(n) => write_tagged_int(&n.to_string(), out),
            Node::BigInt(id) => write_tagged_int(&self.int(id).to_string(), out),
            Node::Local { name, .. } => {
                out.push_str("{\"name\":");
                json_sym(name, out, ctx);
                out.push('}');
            }
            Node::Builtin(op) => {
                out.push_str("{\"name\":");
                json_str(op.name(), out);
                out.push('}');
            }
            // Depth is derived and not rendered.
            Node::Home { leaf, .. } => match leaf {
                HomeLeaf::Module => out.push_str("{\"self\":true}"),
                HomeLeaf::New => out.push_str("{\"new\":true}"),
                HomeLeaf::Value => out.push_str("{\"value\":true}"),
            },
            Node::ModItem { name, .. } => {
                out.push_str("{\"moditem\":");
                json_sym(name, out, ctx);
                out.push('}');
            }
            Node::Recur(id) => {
                let module = self.module(id);
                out.push_str("{\"recur\":[");
                for (i, member) in self.items_by_text(module, ctx).into_iter().enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    out.push('[');
                    json_sym(member.name, out, ctx);
                    out.push(',');
                    self.write_json(self.node(member.node), out, ctx);
                    out.push(']');
                }
                out.push_str("],\"body\":");
                self.write_json(self.node(module.body), out, ctx);
                out.push('}');
            }
            Node::Symbol(s) => {
                let mut dotted = String::from(".");
                ctx.with_str(s, |s| dotted.push_str(s));
                out.push_str("{\"sym\":");
                json_str(&dotted, out);
                out.push('}');
            }
            Node::Str(id) => {
                out.push_str("{\"str\":");
                json_str(self.str(id), out);
                out.push('}');
            }
            // The call spine renders flat, preserving its stored arity.
            Node::App { len, args } => {
                let items = self.nodes(Run::App, args, len);
                let (tag, body) = match items[0] {
                    Node::Home {
                        leaf: HomeLeaf::New,
                        ..
                    } => ("new", &items[1..]),
                    Node::Home {
                        leaf: HomeLeaf::Value,
                        ..
                    } => ("value", &items[1..]),
                    _ => ("app", items),
                };
                out.push_str("{\"");
                out.push_str(tag);
                out.push_str("\":");
                self.write_json_list(body, out, ctx);
                out.push('}');
            }
            Node::Abs(id) => {
                let code = self.lambda(id);
                let head = self.pats(Run::Head, code.head.first, code.head.len);
                self.write_abs_json(head, code.body, out, ctx);
            }
            Node::Unit => out.push_str("{\"unit\":true}"),
            Node::List { len, elems } => {
                out.push_str("{\"list\":");
                self.write_json_list(self.nodes(Run::List, elems, len), out, ctx);
                out.push('}');
            }
            Node::Map { len, entries } => {
                let all = self.nodes(Run::Map, entries, 2 * len);
                let (keys, values) = all.split_at(len as usize);
                out.push_str("{\"map\":[");
                for (i, (&key, &value)) in keys.iter().zip(values).enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    out.push('[');
                    self.write_json(key, out, ctx);
                    out.push(',');
                    self.write_json(value, out, ctx);
                    out.push(']');
                }
                out.push_str("]}");
            }
            // `{"block":[<clause>…]}`: a binding is
            // `{"bind":{"pat":…,"value":…}}`, any other clause its expression.
            Node::Block { len, binds, exprs } => {
                let binds = self.pats(Run::Block, binds, len);
                let exprs = self.nodes(Run::Block, exprs, len);
                out.push_str("{\"block\":[");
                for (i, (&pat, &expr)) in binds.iter().zip(exprs).enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    if pat == Pat::None {
                        self.write_json(expr, out, ctx);
                    } else {
                        out.push_str("{\"bind\":{\"pat\":");
                        self.write_pat_json(pat, out, ctx);
                        out.push_str(",\"value\":");
                        self.write_json(expr, out, ctx);
                        out.push_str("}}");
                    }
                }
                out.push_str("]}");
            }
            // `{"case":{"subject":…,"arms":[{"pat":…,"body":…}, …]}}`.
            Node::Case { len, conds, exprs } => {
                let conds = self.pats(Run::Case, conds, len);
                let exprs = self.nodes(Run::Case, exprs, len + 1);
                let (bodies, subject) = exprs.split_at(len as usize);
                out.push_str("{\"case\":{\"subject\":");
                self.write_json(subject[0], out, ctx);
                out.push_str(",\"arms\":[");
                for (i, (&pat, &body)) in conds.iter().zip(bodies).enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    out.push_str("{\"pat\":");
                    self.write_pat_json(pat, out, ctx);
                    out.push_str(",\"body\":");
                    self.write_json(body, out, ctx);
                    out.push('}');
                }
                out.push_str("]}}");
            }
            #[cfg(debug_assertions)]
            Node::Barrier { .. } => unreachable!("a barrier is not an operand"),
        }
    }

    /// `[e0,e1,…]`.
    fn write_json_list(&self, nodes: &[Node], out: &mut String, ctx: &Ctx) {
        out.push('[');
        for (i, &node) in nodes.iter().enumerate() {
            if i > 0 {
                out.push(',');
            }
            self.write_json(node, out, ctx);
        }
        out.push(']');
    }

    /// A head over `body` as nested `{"abs":{"param":…,"body":…}}`.
    fn write_abs_json(&self, head: &[Pat], body: NodeId, out: &mut String, ctx: &Ctx) {
        out.push_str("{\"abs\":{\"param\":");
        self.write_pat_json(head[0], out, ctx);
        out.push_str(",\"body\":");
        if head.len() == 1 {
            self.write_json(self.node(body), out, ctx);
        } else {
            self.write_abs_json(&head[1..], body, out, ctx);
        }
        out.push_str("}}");
    }

    fn write_pat_json(&self, pat: Pat, out: &mut String, ctx: &Ctx) {
        match pat {
            Pat::None => unreachable!("only a block clause's slot binds nothing"),
            Pat::Discard => out.push_str("{\"discard\":true}"),
            Pat::Unit => out.push_str("{\"unit\":true}"),
            Pat::Bind(name) => {
                out.push_str("{\"bind\":");
                json_sym(name, out, ctx);
                out.push('}');
            }
            Pat::At(name, inner) => {
                out.push_str("{\"at\":[");
                json_sym(name, out, ctx);
                out.push(',');
                self.write_pat_json(self.pat(inner), out, ctx);
                out.push_str("]}");
            }
            Pat::Equal(expr) => self.write_tagged_json("{\"eq\":", expr, out, ctx),
            Pat::Less(expr) => self.write_tagged_json("{\"lt\":", expr, out, ctx),
            Pat::Greater(expr) => self.write_tagged_json("{\"gt\":", expr, out, ctx),
            Pat::TypeKind(kind, inner) => {
                out.push_str("{\"as\":[");
                json_str(kind.name(), out);
                out.push(',');
                self.write_pat_json(self.pat(inner), out, ctx);
                out.push_str("]}");
            }
            Pat::TypeRef(proto, inner) => {
                out.push_str("{\"as\":[");
                self.write_json(self.node(proto), out, ctx);
                out.push(',');
                self.write_pat_json(self.pat(inner), out, ctx);
                out.push_str("]}");
            }
            Pat::Unwrap { inner, .. } => {
                out.push_str("{\"unwrap\":");
                self.write_pat_json(self.pat(inner), out, ctx);
                out.push('}');
            }
            Pat::Or(left, right) => {
                out.push_str("{\"or\":[");
                self.write_pat_json(self.pat(left), out, ctx);
                out.push(',');
                self.write_pat_json(self.pat(right), out, ctx);
                out.push_str("]}");
            }
            Pat::List { len, elems, rest } => {
                out.push_str("{\"listpat\":{\"elems\":[");
                for (i, &elem) in self.pats(Run::PatList, elems, len).iter().enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    self.write_pat_json(elem, out, ctx);
                }
                out.push_str("],\"rest\":");
                self.write_rest_json(rest, out, ctx);
                out.push_str("}}");
            }
            Pat::Map { len, entries, rest } => {
                let all = self.pats(Run::PatMap, entries, 2 * len);
                let (keys, values) = all.split_at(len as usize);
                out.push_str("{\"mappat\":{\"entries\":[");
                for (i, (&key, &value)) in keys.iter().zip(values).enumerate() {
                    if i > 0 {
                        out.push(',');
                    }
                    out.push('[');
                    match key {
                        Pat::Lookup(expr) => self.write_tagged_json("{\"lookup\":", expr, out, ctx),
                        key => {
                            out.push_str("{\"capture\":");
                            self.write_pat_json(key, out, ctx);
                            out.push('}');
                        }
                    }
                    out.push(',');
                    self.write_pat_json(value, out, ctx);
                    out.push(']');
                }
                out.push_str("],\"rest\":");
                self.write_rest_json(rest, out, ctx);
                out.push_str("}}");
            }
            Pat::Lookup(_) => unreachable!("a lookup is only a map pattern's key"),
            Pat::When { inner, gpat, cond } => {
                out.push_str("{\"when\":{\"inner\":");
                self.write_pat_json(self.pat(inner), out, ctx);
                out.push_str(",\"guard\":");
                match gpat.get() {
                    None => out.push_str("null"),
                    Some(gpat) => self.write_pat_json(self.pat(gpat), out, ctx),
                }
                out.push_str(",\"cond\":");
                self.write_json(self.node(cond), out, ctx);
                out.push_str("}}");
            }
            #[cfg(debug_assertions)]
            Pat::Barrier { .. } => unreachable!("a barrier is not an operand"),
        }
    }

    fn write_tagged_json(&self, open: &str, expr: NodeId, out: &mut String, ctx: &Ctx) {
        out.push_str(open);
        self.write_json(self.node(expr), out, ctx);
        out.push('}');
    }

    /// `null` for an exact pattern, otherwise the rest pattern's JSON.
    fn write_rest_json(&self, rest: PatId, out: &mut String, ctx: &Ctx) {
        match rest.get() {
            None => out.push_str("null"),
            Some(rest) => self.write_pat_json(self.pat(rest), out, ctx),
        }
    }

    /// A `recur` group's items in the order of their text, as a rendering
    /// lists them.
    fn items_by_text(&self, module: &Module, ctx: &Ctx) -> Vec<&Member> {
        let mut items: Vec<&Member> = self.members(module)[..module.items as usize]
            .iter()
            .collect();
        items.sort_by_cached_key(|member| ctx.text(member.name));
        items
    }
}

/// `{"Int":"<decimal>"}`: an integer that JSON numbers cannot hold exactly.
fn write_tagged_int(decimal: &str, out: &mut String) {
    out.push_str("{\"Int\":");
    json_str(decimal, out);
    out.push('}');
}

/// Writes the text of `sym`.
pub(crate) fn push_sym(sym: Sym, out: &mut String, ctx: &Ctx) {
    ctx.with_str(sym, |s| out.push_str(s));
}

/// Writes the text of `sym` as a JSON string literal.
fn json_sym(sym: Sym, out: &mut String, ctx: &Ctx) {
    ctx.with_str(sym, |s| json_str(s, out));
}

/// Writes `s` as a quoted and escaped JSON string literal.
pub(crate) fn json_str(s: &str, out: &mut String) {
    out.push('"');
    for ch in s.chars() {
        match ch {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            c => out.push(c),
        }
    }
    out.push('"');
}

#[cfg(test)]
mod tests {
    use alloc::vec;

    use super::*;

    /// The builtins are the first chunk; an expression and an unnamed module
    /// take a name from one count, and a loaded module keeps its own.
    #[test]
    fn chunks_are_named_by_what_made_them() {
        let ctx = Ctx::new();
        let ids = [
            ChunkId::ELLY,
            ctx.parse("1").expect("parses"),
            ctx.compile_module("x = 1").expect("compiles"),
            ctx.parse("1").expect("parses"),
            ctx.compile_module_named("x = 1", &[], Some(Text::from("Foo")))
                .expect("compiles"),
        ];
        let names: Vec<String> = ids
            .iter()
            .map(|id| ctx.chunk(*id).name().to_string())
            .collect();
        assert_eq!(names, ["Elly", "__eval_0", "__module_1", "__eval_2", "Foo"]);
    }

    /// A source that fails to parse adds no chunk and takes no name.
    #[test]
    fn a_failed_parse_adds_no_chunk() {
        let ctx = Ctx::new();
        assert!(ctx.parse("f x").is_err());
        assert!(ctx.compile_module("x = y").is_err());
        let id = ctx.parse("1").expect("parses");
        assert_eq!(id, ChunkId::at(1));
        assert_eq!(ctx.chunk(id).name().as_str(), "__eval_0");
    }

    /// A `recur` group nested in another and in a module item: every module
    /// entry comes after its parent's, and the members keep their order.
    #[test]
    fn a_nested_module_comes_after_its_parent() {
        let ctx = Ctx::new();
        let src = "f = recur (g = recur (h = 1) h) g\nlocal l = 2\nconst c\n__main = f";
        let id = ctx.compile_module(src).expect("compiles");
        let chunk = ctx.chunk(id);
        let parents: Vec<ModId> = chunk.modules.iter().map(|m| m.parent).collect();
        assert_eq!(parents, vec![ModId::NONE, ModId(0), ModId(1)]);
        let top = chunk.module(chunk.top());
        let names: Vec<String> = chunk
            .members(top)
            .iter()
            .map(|m| ctx.text(m.name).to_string())
            .collect();
        assert_eq!(names, ["f", "l", "c"]);
        assert_eq!((top.items, top.locals), (1, 1));
        assert!(
            chunk.members(top)[2].node.get().is_none(),
            "an iota has no body"
        );
        assert_eq!(
            chunk.to_sexp(top.body, &ctx),
            "(moditem f)",
            "__main is the body"
        );
    }
}