mod binding;

mod compile_eval;

mod control;

pub(in crate::compiler::special) mod iteration;

mod labels;

mod lambda;

mod macros;

mod structure;

use tracing::debug;

use crate::ast::Expr;

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

use crate::runtime::SymbolTable;

use crate::ast::WasmType;

use super::context::CompileContext;

use super::emit::FunctionEmitter;

pub(in crate::compiler) use control::{

    form_diverges_for_test, is_runtime_test, is_truthy, reject_non_boolean_runtime_test,

};

pub(in crate::compiler) use lambda::monomorph::lookup_or_emit_monomorph;

pub(in crate::compiler) use lambda::{

    is_capture_free, try_emit_lambda_for_host_iter, try_emit_lambda_for_value,

};

pub(in crate::compiler) use structure::rhs_has_runtime_store;

pub(in crate::compiler) use structure::set_place as setf_set_place;

pub(super) type EvalFn = fn(&mut SymbolTable, &[Expr]) -> Result<Expr>;

pub(super) type CompileFn =

    fn(&mut CompileContext, &mut FunctionEmitter, &mut SymbolTable, &[Expr]) -> Result<()>;

pub(super) type StackFn =

    fn(&mut CompileContext, &mut FunctionEmitter, &mut SymbolTable, &[Expr]) -> Result<WasmType>;

/// Canonical metadata for a built-in special form. Mirrors `NativeSpec`

/// in `native/mod.rs` — every name appears exactly once across the four

/// dispatch paths so adding a form is a single row and missing handlers

/// surface at compile time. `compile` is the default effect path; the

/// optional `effect` overrides it when a form has specialized

/// effect-position codegen (e.g. DOLIST drops the loop's result).

pub(super) struct SpecialFormSpec {

    pub name: &'static str,

    pub eval: EvalFn,

    pub compile: CompileFn,

    pub stack: Option<StackFn>,

    pub effect: Option<CompileFn>,

}

const DOMAINS: &[&[SpecialFormSpec]] = &[

    control::FORMS,

    binding::FORMS,

    lambda::FORMS,

    macros::FORMS,

    compile_eval::FORMS,

    iteration::FORMS,

    labels::FORMS,

    structure::FORMS,

];

/// True if `name` is a special form (LET, DEFUN, QUOTE, …). The effect-position

/// fallback uses this to keep routing definition / non-value forms through

/// `eval_value`, while value-producing native / host-fn calls are compiled and

/// their result dropped (so argument effects emit).

    }

    }

    }

        },

    }

#[cfg(test)]

mod tests {

    use super::*;

    use std::collections::HashSet;

    #[test]

                "duplicate special-form registration: {}",

                spec.name

            );

        }

    #[test]

                "lookup({}) returned None",

                spec.name

            );

        }

}