//! Closure-signature registry.

//!

//! Tier 1.5 promotes lambdas from compile-time stringification to real

//! wasm functions. To pass a lambda around as a runtime value we need

//! a wasm GC type that bundles a typed funcref with its captured-env

//! ref — that's `$closure_<sig>`. Closures sharing the same

//! `(arg-types) -> ret-type` signature share the wasm closure-struct

//! type and the funcref signature; their env-struct types vary

//! independently per scope so two closures with disjoint captures

//! don't collide.

//!

//! This slice ships the per-signature interner that the

//! `WasmType::Closure(sig_id)` arm of `wasm_val_type` resolves through;

//! the env-struct allocator and monomorph cache (used to lower

//! `(funcall closure-arg ...)` and `(defun ...)` recursion through a

//! real fn) land alongside their first call-site so the no-dead-code

//! rule stays clean. See `doc/adr/0027-lambda-real-wasm-fn.org` for the

//! full design.

#[cfg(test)]

mod tests;

use std::collections::HashMap;

use wasm_encoder::{

    CompositeInnerType, CompositeType, FieldType, Function, HeapType, RefType, StorageType,

    StructType, SubType, ValType,

};

use super::CompileContext;

use crate::ast::{ClosureSigId, Expr, LambdaParams, WasmType};

use crate::error::{Error, Result};

/// Per-signature closure type metadata. Held in `CompileContext` so

/// the compiler can look up `$closure_<sig>` and `$fn_<sig>` indices

/// from a [`ClosureSigId`] without rehashing the signature on each

/// reference. `fn_type_idx` is the typed funcref's wasm type — needed

/// at every `call_ref` site so the engine can validate the funcref's

/// shape statically.

#[derive(Debug, Clone)]

pub(crate) struct ClosureSig {

    pub closure_type_idx: u32,

    pub fn_type_idx: u32,

    pub params: Vec<WasmType>,

    pub result: WasmType,

}

/// Layout of a per-scope `$env_<id>` struct holding values captured by

/// a lambda body. One entry per `CaptureSet` name, in insertion order

/// so the outer site (which fills the struct) and the helper-fn body

/// (which reads it) walk the same field indices. Field types are

/// captured at the point [`CompileContext::intern_env_struct`] is

/// called from the lookup of each name in the caller's symbol table.

#[derive(Debug, Clone)]

pub(crate) struct EnvStructLayout {

    pub type_idx: u32,

    pub fields: Vec<EnvField>,

}

#[derive(Debug, Clone)]

pub(crate) struct EnvField {

    pub name: String,

    pub ty: WasmType,

}

#[derive(Debug, Default, Clone)]

pub(crate) struct ClosureRegistry {

    sigs: HashMap<(Vec<WasmType>, WasmType), ClosureSigId>,

    by_id: Vec<ClosureSig>,

    next_sig_id: u32,

    helper_count: u32,

    env_struct_count: u32,

    closure_literal_data_idx: Option<u32>,

}

/// Snapshot of `CompileContext`'s local-pool fields so a helper-fn

/// emit can carve out a fresh allocator without clobbering the caller's

/// in-flight state. Rebound by [`CompileContext::restore_local_pool`].

pub(crate) struct LocalPoolSnapshot {

    next_local: u32,

    local_types: Vec<(WasmType, u32)>,

    closure_bodies: HashMap<u32, (LambdaParams, Expr)>,

    serializer: super::super::layout::OutputSerializer,

}

impl CompileContext {

    /// Returns a `(ref null $closure_<sig>)` valtype. Helper for the

    /// `WasmType::Closure(sig)` arm of `wasm_val_type`.

    /// Records a value-position lambda's source, keyed by the wasm local its

    /// closure value was bound to (see [`Self::closure_bodies`]).

    /// The source `(params, body)` of the closure value bound to `local_idx`,

    /// if one was recorded — lets a higher-order native inline the body per

    /// element with the actual element type instead of `call_ref`ing the

    /// fixed-signature closure.

    /// Drops any recorded body for `local_idx`. Called when a `setf` overwrites

    /// a closure local: the recorded source no longer describes the value now in

    /// that local, so an inline would apply the WRONG closure. Forgetting it

    /// falls the higher-order native back to the (always-correct) `call_ref`.

    /// Look up or register the wasm types behind a closure signature.

    /// Returns the same id for repeat calls with the same signature so

    /// distinct lambdas with the same shape share `$fn_<sig>` and

    /// `$closure_<sig>`.

        ];

        self.closures.next_sig_id =

    /// Registers a fresh `$env_<id>` struct type for one captured-name

    /// scope. Each call allocates a new wasm type (no dedup) — different

    /// lambdas captures different names even when shapes coincide, and

    /// the per-call cost is one type-section entry. Caller's

    /// responsibility to populate the layout in declared order.

                mutable: false,

    /// Allocates a unique helper-fn name for a lambda body. Used by the

    /// emit path so distinct lambda bodies get stable wasm names even

    /// when sharing a `ClosureSigId`.

    /// Saves the in-flight local-pool state (local allocator + types +

    /// serializer cursor) so a helper-fn body can be emitted into a

    /// fresh pool. The new pool numbers locals from `next_local_base`,

    /// which the caller picks to match the helper fn's wasm-level

    /// layout — script-mode entry points use `LOCAL_POOL_BASE` (5

    /// preallocated slots), lambda helpers use `param_count` (no

    /// preallocated slots, locals begin immediately after params).

    /// Pair with [`Self::restore_local_pool`] once the helper's

    /// `Function` has been finished and queued.

    /// Builds the locals declaration for a lambda helper fn whose

    /// `param_count` slots are reserved (env + user params, all func

    /// args). Mirrors [`Self::build_locals_declaration`] but starts

    /// numbering after the params and skips the script-mode preallocated

    /// pool — helper bodies use the local-pool allocator only.

    /// Returns the passive-data-segment idx for the literal `<closure>`

    /// rendering used by [`OutputSerializer::write_debug_closure_from_stack`].

    /// The bytes are interned on first use so a module that constructs

    /// many closures shares one data segment.

}

pub(crate) const CLOSURE_LITERAL_BYTES: &[u8] = b"<closure>";

pub(crate) const CLOSURE_LITERAL_LEN: u32 = CLOSURE_LITERAL_BYTES.len() as u32;