//! Resolved wasm function / type indices for a `CompileContext`.

//!

//! Emit code used to resolve indices by string — `ctx.func("ratio_new")` /

//! `ctx.type_idx("pair")` — through a `HashMap[key]` that **panicked** on a

//! miss (a missing helper, or a name registered in one module mode but read in

//! the other, e.g. `log` before it was added to eval mode). The name set is a

//! CLOSED, STATIC universe registered by the context constructor, so a miss is

//! a compiler bug — but it must surface as a structured `Error::Compile`, never

//! a SIGABRT (CLAUDE.md).

//!

//! `WasmIds` resolves every emit-referenced name ONCE at the end of

//! construction into a typed field. Emit then reads `ctx.ids.ratio_new` — a

//! plain `u32`, infallible, no hashing, no panic. A forgotten field is a Rust

//! "missing field in initializer" compile error; the `EntityKind` resolver is an

//! exhaustive `match`, so a new entity variant without a mapping is a Rust

//! compile error too. **The missing-key panic class cannot recur.**

//!

//! Indices are per-compilation, module-internal wasm section indices — never

//! serialized, never crossing a process/disk/rpc boundary — so this is a pure

//! internal-representation change with no effect on emitted bytes or script

//! portability.

use crate::ast::EntityKind;

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

use super::CompileContext;

/// Wasm function indices referenced by emit code, resolved at construction.

/// Common helpers are present in BOTH module modes; the three `get_*` host

/// imports are SCRIPT-mode only (their emit sites — the entity natives — run

/// only on the script path), so they are `Option` and read through accessors

/// that return a structured error rather than panicking if read in eval mode.

#[derive(Debug, Clone)]

pub(in crate::compiler) struct WasmIds {

    // ratio helpers

    pub gcd: u32,

    pub ratio_new: u32,

    pub ratio_add: u32,

    pub ratio_sub: u32,

    pub ratio_mul: u32,

    pub ratio_div: u32,

    pub ratio_eq: u32,

    pub ratio_lt: u32,

    pub ratio_from_i64: u32,

    pub ratio_to_i64: u32,

    // unit-term helpers

    pub unit_singleton: u32,

    pub unit_mul: u32,

    pub unit_negate: u32,

    pub unit_eq: u32,

    pub materialize_unit: u32,

    // commodity helpers

    pub commodity_add: u32,

    pub commodity_sub: u32,

    pub commodity_mul: u32,

    pub commodity_div: u32,

    pub commodity_mul_by_ratio: u32,

    pub commodity_div_by_ratio: u32,

    pub commodity_neg: u32,

    pub commodity_eq: u32,

    pub commodity_lt: u32,

    pub commodity_assert_atomic: u32,

    pub commodity_new_with_term: u32,

    // pair + string

    pub pair_new: u32,

    pub string_eq: u32,

    // boundary imports

    pub nomi_raise: u32, // both modes

    pub log: u32,        // both modes

    // eval-mode-only import (catch-each lowering)

    pub nomi_catch_each: Option<u32>,

    // script-mode-only env imports (entity-native emit sites)

    pub get_output_offset: Option<u32>,

    pub get_input_offset: Option<u32>,

    pub get_input_entities_count: Option<u32>,

    // types

    pub ty_i8_array: u32,

    pub ty_ratio: u32,

    pub ty_pair: u32,

    pub ty_commodity: u32,

    pub ty_unit_term: u32,

    pub ty_nomi_condition: u32,

    // entity struct types (indexed by EntityKind via `entity_type`)

    pub ty_account: u32,

    pub ty_commodity_entity: u32,

    pub ty_transaction: u32,

    pub ty_split: u32,

    pub ty_tag_entity: u32,

    pub ty_price: u32,

    pub ty_ssh_key: u32,

}

impl WasmIds {

    /// Pre-resolution poison. Every index is `u32::MAX` (an out-of-range wasm

    /// section index), so a read *before* `resolve_ids` overwrites it fails wasm

    /// validation loudly rather than silently emitting index 0. The two public

    /// constructors overwrite this unconditionally before emit can run; it only

    /// fills the `ids` field for the brief construction window in which the

    /// helper indices it would resolve don't yet exist. This is NOT a `Default`

    /// — it's a single named poison value, and the real completeness checkpoint

    /// is the all-fields literal in `resolve_ids`.

    pub(super) const UNRESOLVED: Self = Self {

        gcd: u32::MAX,

        ratio_new: u32::MAX,

        ratio_add: u32::MAX,

        ratio_sub: u32::MAX,

        ratio_mul: u32::MAX,

        ratio_div: u32::MAX,

        ratio_eq: u32::MAX,

        ratio_lt: u32::MAX,

        ratio_from_i64: u32::MAX,

        ratio_to_i64: u32::MAX,

        unit_singleton: u32::MAX,

        unit_mul: u32::MAX,

        unit_negate: u32::MAX,

        unit_eq: u32::MAX,

        materialize_unit: u32::MAX,

        commodity_add: u32::MAX,

        commodity_sub: u32::MAX,

        commodity_mul: u32::MAX,

        commodity_div: u32::MAX,

        commodity_mul_by_ratio: u32::MAX,

        commodity_div_by_ratio: u32::MAX,

        commodity_neg: u32::MAX,

        commodity_eq: u32::MAX,

        commodity_lt: u32::MAX,

        commodity_assert_atomic: u32::MAX,

        commodity_new_with_term: u32::MAX,

        pair_new: u32::MAX,

        string_eq: u32::MAX,

        nomi_raise: u32::MAX,

        log: u32::MAX,

        nomi_catch_each: None,

        get_output_offset: None,

        get_input_offset: None,

        get_input_entities_count: None,

        ty_i8_array: u32::MAX,

        ty_ratio: u32::MAX,

        ty_pair: u32::MAX,

        ty_commodity: u32::MAX,

        ty_unit_term: u32::MAX,

        ty_nomi_condition: u32::MAX,

        ty_account: u32::MAX,

        ty_commodity_entity: u32::MAX,

        ty_transaction: u32::MAX,

        ty_split: u32::MAX,

        ty_tag_entity: u32::MAX,

        ty_price: u32::MAX,

        ty_ssh_key: u32::MAX,

    };

    /// The wasm struct-type index for an entity kind. Exhaustive over

    /// `EntityKind` — a new variant without an arm is a Rust compile error.

    /// `Condition` shares the `$nomi_condition` struct (exception support),

    /// matching `EntityKind::type_name`.

    #[must_use]

        }

    /// Stores the wasm struct-type index for an entity kind as it registers in

    /// `new_skeleton`. Exhaustive over `EntityKind` (mirrors `entity_type`), so

    /// a new variant without an arm is a Rust compile error.

        };

    /// The ratio comparison helper index for a comparison operator. The

    /// comparison dispatch only ever passes `"="` / `"<"` (closed set).

        }

    /// The commodity comparison helper index for a comparison operator.

        }

    /// A mode-specific import index, or a structured error if read in a module

    /// mode that didn't register it (rather than panicking).

}

impl CompileContext {

    /// Resolves every emit-referenced HELPER-FUNCTION name from the

    /// (fully-declared) `func_names` map into the function fields of `WasmIds`,

    /// preserving the TYPE fields already populated in `new_skeleton` (the

    /// type-ref accessors need those mid-skeleton, before this runs). Called

    /// ONCE after all `declare_*` have run. A missing common name is a

    /// structured `Error::Compile` (a compiler bug surfaced cleanly, not a

    /// panic); the mode-specific imports resolve to `None` in the other mode by

    /// design.

        Ok(WasmIds {

            // Type fields were populated in `new_skeleton` (the type-ref

            // accessors needed them while declaring helper signatures); carry

            // them through unchanged.

        })

}