fn eval_lambda(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    lambda(args)

}

fn spec_compile_lambda(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    compile_lambda_form(ctx, emit, symbols, args)

}

pub(super) fn compile_lambda_form(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let result = lambda(args)?;

    emit_closure_or_stringify(ctx, emit, symbols, &result)

}

pub(super) fn compile_function_form(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let result = function_form(symbols, args)?;

    emit_closure_or_stringify(ctx, emit, symbols, &result)

}

fn emit_closure_or_stringify(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &SymbolTable,

    result: &Expr,

) -> Result<()> {

    if let Expr::Lambda(params, body) = result

        && let Some(sig) = try_emit_lambda_for_value(ctx, emit, symbols, params, body)?

        return serialize_stack_to_output(ctx, emit, crate::ast::WasmType::Closure(sig));

    }

    compile_string(ctx, emit, &format_expr(result))

}

pub(in crate::compiler) fn is_capture_free(

    symbols: &SymbolTable,

    params: &LambdaParams,

    body: &Expr,

) -> bool {

    if !params.optional.is_empty()

        || params.rest.is_some()

        || !params.key.is_empty()

        || !params.aux.is_empty()

        return false;

    }

    references_no_free_variable(symbols, &params.required, body)

}

fn references_no_free_variable(symbols: &SymbolTable, bound: &[String], expr: &Expr) -> bool {

    match expr {

        Expr::Symbol(name) => {

            bound.iter().any(|p| p == name)

                || (!resolves_to_variable(symbols, name) && !has_function_binding(symbols, name))

        Expr::Quote(_) => true,

        Expr::List(elems) if matches!(elems.first(), Some(Expr::Symbol(h)) if h.eq_ignore_ascii_case("quote")) => {

        Expr::List(elems) if matches!(elems.first(), Some(Expr::Symbol(h)) if resolves_to_macro(symbols, h)) => {

            false

        Expr::Quasiquote(inner) | Expr::Unquote(inner) | Expr::UnquoteSplicing(inner) => {

            references_no_free_variable(symbols, bound, inner)

        Expr::Lambda(inner_params, inner_body) => {

            param_default_exprs(inner_params)

                .all(|d| references_no_free_variable(symbols, bound, d))

                && references_no_free_variable(symbols, bound, inner_body)

        Expr::List(elems) => elems

            .iter()

            .all(|e| references_no_free_variable(symbols, bound, e)),

        Expr::Cons(car, cdr) => {

            references_no_free_variable(symbols, bound, car)

        _ => true,

}

fn param_default_exprs(params: &LambdaParams) -> impl Iterator<Item = &Expr> {

    params

        .optional

        .iter()

        .chain(&params.key)

        .chain(&params.aux)

        .filter_map(|(_, default)| default.as_ref())

}

fn resolves_to_variable(symbols: &SymbolTable, name: &str) -> bool {

    matches!(

        symbols.lookup(name).map(|sym| sym.kind()),

}

fn resolves_to_macro(symbols: &SymbolTable, name: &str) -> bool {

    matches!(

        symbols.lookup(name).map(|sym| sym.kind()),

}

fn has_function_binding(symbols: &SymbolTable, name: &str) -> bool {

    symbols

        .lookup(name)

        .is_some_and(|sym| sym.function().is_some())

}

pub(in crate::compiler) fn try_emit_lambda_for_value(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &SymbolTable,

    params: &LambdaParams,

    body: &Expr,

) -> Result<Option<crate::ast::ClosureSigId>> {

    if !emit::is_v1_eligible(symbols, params, body) {

        return Ok(None);

    }

    let sig = emit::emit_lambda_value(ctx, emit, symbols, params, body)?;

    Ok(Some(sig))

}

pub(in crate::compiler) fn try_emit_lambda_for_host_iter(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &SymbolTable,

    params: &LambdaParams,

    body: &Expr,

    user_param_types: &[WasmType],

) -> Result<Option<crate::ast::ClosureSigId>> {

    if !emit::is_v1_eligible(symbols, params, body) {

    }

    let sig = emit::emit_lambda_value_typed(

        ctx,

        emit,

        symbols,

        params,

        body,

        user_param_types,

        emit::CallingConvention::HostAnyref,

    )?;

    Ok(Some(sig))

}

pub(super) fn compile_funcall(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    if args.is_empty() {

        return Err(Error::Compile(

            "funcall requires at least a function argument".to_string(),

        ));

    }

    compile_call(ctx, emit, symbols, args)

}

pub(super) fn compile_funcall_for_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    if args.is_empty() {

    }

    compile_call_for_stack(ctx, emit, symbols, args)

}

pub(super) fn compile_apply_form(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let all_args = build_apply_call(symbols, args)?;

    compile_call(ctx, emit, symbols, &all_args)

}

fn build_apply_call(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Vec<Expr>> {

    if args.len() < 2 {

        return Err(Error::Compile(

            "apply requires at least a function and one argument".to_string(),

        ));

    }

    let leading = &args[..args.len() - 1];

    let mut all_args: Vec<Expr> = Vec::with_capacity(leading.len() + 1);

    all_args.push(resolve_apply_designator(symbols, &leading[0])?);

    for arg in &leading[1..] {

        all_args.push(eval_value(symbols, arg)?);

    all_args.extend(spread_apply_last_arg(symbols, &args[args.len() - 1])?);

    Ok(all_args)

}

fn spread_apply_last_arg(symbols: &mut SymbolTable, arg: &Expr) -> Result<Vec<Expr>> {

    if let Expr::List(elems) = arg

        && let Some(Expr::Symbol(head)) = elems.first()

        && head.eq_ignore_ascii_case("LIST")

        && resolves_to_native_list(symbols, head)

        return Ok(elems[1..].to_vec());

    }

    match eval_value(symbols, arg)? {

        Expr::Quote(inner) => match *inner {

            Expr::List(elems) => Ok(elems),

            _ => Err(apply_last_arg_error()),

        _ => Err(apply_last_arg_error()),

}

fn resolves_to_native_list(symbols: &SymbolTable, head: &str) -> bool {

    match symbols.lookup(head) {

        Some(sym) => sym.function().is_none() && sym.value().is_none(),

}

fn apply_last_arg_error() -> Error {

    Error::Compile(

        "apply: last argument must be a literal list — `(list …)`, a quoted \

         list, or nil (a runtime list's arity isn't known at compile time)"

            .to_string(),

    )

}

pub(super) fn lambda(args: &[Expr]) -> Result<Expr> {

    if args.len() < 2 {

        return Err(Error::Compile(

            "LAMBDA requires a parameter list and body".to_string(),

        ));

    }

    let params = parse_lambda_params("LAMBDA", &args[0])?;

    let body = if args.len() == 2 {

        args[1].clone()

        let mut forms = Vec::with_capacity(args.len());

        forms.push(Expr::Symbol("BEGIN".to_string()));

        forms.extend_from_slice(&args[1..]);

        Expr::List(forms)

    Ok(Expr::Lambda(params, Box::new(body)))

}

pub(super) fn function_form(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() != 1 {

    }

    match &args[0] {

        Expr::Symbol(name) => {

            let func = symbols

                .lookup(name)

                .and_then(|s| s.function().cloned())

                .ok_or_else(|| Error::Compile(format!("'{name}' has no function definition")))?;

            Ok(func)

        Expr::List(elems) if matches!(elems.first(), Some(Expr::Symbol(s)) if s == "LAMBDA") => {

            lambda(&elems[1..])

        _ => Err(Error::Compile(

            "FUNCTION: argument must be a symbol or lambda expression".to_string(),

        )),

}

pub(super) fn funcall(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.is_empty() {

    }

    tracing::debug!(args = args.len(), "compiling funcall");

    super::super::expr::call(symbols, args)

}

pub(super) fn apply(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    if args.len() < 2 {

    }

    let leading = &args[..args.len() - 1];

    let mut all_args: Vec<Expr> = Vec::with_capacity(leading.len() + 1);

    all_args.push(resolve_apply_designator(symbols, &leading[0])?);

    for arg in &leading[1..] {

        all_args.push(eval_value(symbols, arg)?);

    all_args.extend(spread_apply_last_arg(symbols, &args[args.len() - 1])?);

    super::super::expr::call(symbols, &all_args)

}

pub(super) fn resolve_apply_designator(symbols: &mut SymbolTable, arg: &Expr) -> Result<Expr> {

    match arg {

        Expr::Symbol(name) => {

            let sym = symbols

                .lookup(name)

                .ok_or_else(|| Error::UndefinedSymbol(name.clone()))?;

            if sym.value().is_some() {

                Ok(Expr::Symbol(name.clone()))

        _ => eval_value(symbols, arg),

}