Function handle_function_parameters

src/modules/function/invocation_utils.rs:194–242

(
    meta: &mut ParserMetadata,
    id: usize,
    fun: FunctionDecl,
    args: &[Type],
    vars: &[bool],
    tok: Option<Token>,
)

}

pub fn handle_function_parameters(
    meta: &mut ParserMetadata,
    id: usize,
    fun: FunctionDecl,
    args: &[Type],
    vars: &[bool],
    tok: Option<Token>,
) -> Result<(Type, usize), Failure> {
    // Check if the function arguments that are references are passed as variables and not as values
    for (index, (arg, var)) in izip!(fun.args.iter(), vars.iter()).enumerate() {
        let is_ref = arg.is_ref;
        let arg_name = &arg.name;
        if is_ref && !var {
            let fun_name = &fun.name;
            let ordinal = ordinal_number(index);
            return error!(meta, tok, format!("Cannot pass {ordinal} argument '{arg_name}' as a reference to the function '{fun_name}' because it is not a variable"));
        }
    }

    // On first invocation, run first-pass with declared types (or Generic) to emit correct warnings.
    if !meta.fun_cache.is_first_pass_done(id) {
        let declared_types: Vec<Type> = fun.args.iter().map(|arg| arg.kind.clone()).collect();
        // We set persist to false, because we don't want to cache the function instance
        let _ = meta.with_first_pass_ctx(true, |meta| {
            run_function_with_args(meta, fun.clone(), &declared_types, tok.clone(), false)
        });
        meta.fun_cache.set_first_pass_done(id);
    }

    // If the function was previously called with the same arguments, return the cached variant
    let result = match meta
        .fun_cache
        .get_instances(id)
        .unwrap()
        .iter()
        .find(|fun| fun.args == args)
    {
        Some(fun) => Ok((fun.returns.clone(), fun.variant_id)),
        None => Ok(run_function_with_args(
            meta,
            fun,
            args,
            tok,
            !meta.first_pass_ctx,
        )?),
    };

    result
}

fn handle_similar_function(meta: &ParserMetadata, name: &str) -> Option<String> {
    let vars = Vec::from_iter(meta.get_fun_names());