builtin.rs

use std::{
    hash::{Hash, Hasher},
    rc::Rc,
};

use acvm::{AcirField, FieldElement};
use builtin_helpers::{
    block_expression_to_value, check_argument_count, check_function_not_yet_resolved,
    check_one_argument, check_three_arguments, check_two_arguments, get_bool, get_expr, get_field,
    get_format_string, get_function_def, get_module, get_quoted, get_slice, get_struct,
    get_trait_constraint, get_trait_def, get_trait_impl, get_tuple, get_type, get_typed_expr,
    get_u32, get_unresolved_type, has_named_attribute, hir_pattern_to_tokens,
    mutate_func_meta_type, parse, replace_func_meta_parameters, replace_func_meta_return_type,
};
use chumsky::{chain::Chain, prelude::choice, Parser};
use im::Vector;
use iter_extended::{try_vecmap, vecmap};
use noirc_errors::Location;
use num_bigint::BigUint;
use rustc_hash::FxHashMap as HashMap;

use crate::{
    ast::{
        ArrayLiteral, BlockExpression, ConstrainKind, Expression, ExpressionKind, FunctionKind,
        FunctionReturnType, IntegerBitSize, LValue, Literal, Pattern, Statement, StatementKind,
        UnaryOp, UnresolvedType, UnresolvedTypeData, Visibility,
    },
    hir::def_collector::dc_crate::CollectedItems,
    hir::{
        comptime::{
            errors::IResult,
            value::{ExprValue, TypedExpr},
            InterpreterError, Value,
        },
        def_map::ModuleId,
    },
    hir_def::function::FunctionBody,
    lexer::Lexer,
    macros_api::{HirExpression, HirLiteral, Ident, ModuleDefId, NodeInterner, Signedness},
    node_interner::{DefinitionKind, TraitImplKind},
    parser::{self},
    token::{Attribute, SecondaryAttribute, Token},
    Kind, QuotedType, ResolvedGeneric, Shared, Type, TypeVariable,
};

use self::builtin_helpers::{get_array, get_str, get_u8};
use super::Interpreter;

pub(crate) mod builtin_helpers;

impl<'local, 'context> Interpreter<'local, 'context> {
    pub(super) fn call_builtin(
        &mut self,
        name: &str,
        arguments: Vec<(Value, Location)>,
        return_type: Type,
        location: Location,
    ) -> IResult<Value> {
        let interner = &mut self.elaborator.interner;
        let call_stack = &self.elaborator.interpreter_call_stack;
        match name {
            "array_as_str_unchecked" => array_as_str_unchecked(interner, arguments, location),
            "array_len" => array_len(interner, arguments, location),
            "assert_constant" => Ok(Value::Bool(true)),
            "as_slice" => as_slice(interner, arguments, location),
            "expr_as_array" => expr_as_array(interner, arguments, return_type, location),
            "expr_as_assert" => expr_as_assert(interner, arguments, return_type, location),
            "expr_as_assert_eq" => expr_as_assert_eq(interner, arguments, return_type, location),
            "expr_as_assign" => expr_as_assign(interner, arguments, return_type, location),
            "expr_as_binary_op" => expr_as_binary_op(interner, arguments, return_type, location),
            "expr_as_block" => expr_as_block(interner, arguments, return_type, location),
            "expr_as_bool" => expr_as_bool(interner, arguments, return_type, location),
            "expr_as_cast" => expr_as_cast(interner, arguments, return_type, location),
            "expr_as_comptime" => expr_as_comptime(interner, arguments, return_type, location),
            "expr_as_function_call" => {
                expr_as_function_call(interner, arguments, return_type, location)
            }
            "expr_as_if" => expr_as_if(interner, arguments, return_type, location),
            "expr_as_index" => expr_as_index(interner, arguments, return_type, location),
            "expr_as_integer" => expr_as_integer(interner, arguments, return_type, location),
            "expr_as_let" => expr_as_let(interner, arguments, return_type, location),
            "expr_as_member_access" => {
                expr_as_member_access(interner, arguments, return_type, location)
            }
            "expr_as_method_call" => {
                expr_as_method_call(interner, arguments, return_type, location)
            }
            "expr_as_repeated_element_array" => {
                expr_as_repeated_element_array(interner, arguments, return_type, location)
            }
            "expr_as_repeated_element_slice" => {
                expr_as_repeated_element_slice(interner, arguments, return_type, location)
            }
            "expr_as_slice" => expr_as_slice(interner, arguments, return_type, location),
            "expr_as_tuple" => expr_as_tuple(interner, arguments, return_type, location),
            "expr_as_unary_op" => expr_as_unary_op(interner, arguments, return_type, location),
            "expr_as_unsafe" => expr_as_unsafe(interner, arguments, return_type, location),
            "expr_has_semicolon" => expr_has_semicolon(interner, arguments, location),
            "expr_is_break" => expr_is_break(interner, arguments, location),
            "expr_is_continue" => expr_is_continue(interner, arguments, location),
            "expr_resolve" => expr_resolve(self, arguments, location),
            "is_unconstrained" => Ok(Value::Bool(true)),
            "fmtstr_quoted_contents" => fmtstr_quoted_contents(interner, arguments, location),
            "fresh_type_variable" => fresh_type_variable(interner),
            "function_def_add_attribute" => function_def_add_attribute(self, arguments, location),
            "function_def_body" => function_def_body(interner, arguments, location),
            "function_def_has_named_attribute" => {
                function_def_has_named_attribute(interner, arguments, location)
            }
            "function_def_is_unconstrained" => {
                function_def_is_unconstrained(interner, arguments, location)
            }
            "function_def_module" => function_def_module(interner, arguments, location),
            "function_def_name" => function_def_name(interner, arguments, location),
            "function_def_parameters" => function_def_parameters(interner, arguments, location),
            "function_def_return_type" => function_def_return_type(interner, arguments, location),
            "function_def_set_body" => function_def_set_body(self, arguments, location),
            "function_def_set_parameters" => function_def_set_parameters(self, arguments, location),
            "function_def_set_return_type" => {
                function_def_set_return_type(self, arguments, location)
            }
            "function_def_set_return_public" => {
                function_def_set_return_public(self, arguments, location)
            }
            "function_def_set_unconstrained" => {
                function_def_set_unconstrained(self, arguments, location)
            }
            "module_add_item" => module_add_item(self, arguments, location),
            "module_functions" => module_functions(self, arguments, location),
            "module_has_named_attribute" => module_has_named_attribute(self, arguments, location),
            "module_is_contract" => module_is_contract(self, arguments, location),
            "module_name" => module_name(interner, arguments, location),
            "modulus_be_bits" => modulus_be_bits(interner, arguments, location),
            "modulus_be_bytes" => modulus_be_bytes(interner, arguments, location),
            "modulus_le_bits" => modulus_le_bits(interner, arguments, location),
            "modulus_le_bytes" => modulus_le_bytes(interner, arguments, location),
            "modulus_num_bits" => modulus_num_bits(interner, arguments, location),
            "quoted_as_expr" => quoted_as_expr(arguments, return_type, location),
            "quoted_as_module" => quoted_as_module(self, arguments, return_type, location),
            "quoted_as_trait_constraint" => quoted_as_trait_constraint(self, arguments, location),
            "quoted_as_type" => quoted_as_type(self, arguments, location),
            "quoted_eq" => quoted_eq(arguments, location),
            "quoted_tokens" => quoted_tokens(arguments, location),
            "slice_insert" => slice_insert(interner, arguments, location),
            "slice_pop_back" => slice_pop_back(interner, arguments, location, call_stack),
            "slice_pop_front" => slice_pop_front(interner, arguments, location, call_stack),
            "slice_push_back" => slice_push_back(interner, arguments, location),
            "slice_push_front" => slice_push_front(interner, arguments, location),
            "slice_remove" => slice_remove(interner, arguments, location, call_stack),
            "str_as_bytes" => str_as_bytes(interner, arguments, location),
            "struct_def_add_attribute" => struct_def_add_attribute(interner, arguments, location),
            "struct_def_add_generic" => struct_def_add_generic(interner, arguments, location),
            "struct_def_as_type" => struct_def_as_type(interner, arguments, location),
            "struct_def_fields" => struct_def_fields(interner, arguments, location),
            "struct_def_generics" => struct_def_generics(interner, arguments, location),
            "struct_def_has_named_attribute" => {
                struct_def_has_named_attribute(interner, arguments, location)
            }
            "struct_def_module" => struct_def_module(self, arguments, location),
            "struct_def_name" => struct_def_name(interner, arguments, location),
            "struct_def_set_fields" => struct_def_set_fields(interner, arguments, location),
            "to_le_radix" => to_le_radix(arguments, return_type, location),
            "trait_constraint_eq" => trait_constraint_eq(interner, arguments, location),
            "trait_constraint_hash" => trait_constraint_hash(interner, arguments, location),
            "trait_def_as_trait_constraint" => {
                trait_def_as_trait_constraint(interner, arguments, location)
            }
            "trait_def_eq" => trait_def_eq(interner, arguments, location),
            "trait_def_hash" => trait_def_hash(interner, arguments, location),
            "trait_impl_methods" => trait_impl_methods(interner, arguments, location),
            "trait_impl_trait_generic_args" => {
                trait_impl_trait_generic_args(interner, arguments, location)
            }
            "type_as_array" => type_as_array(arguments, return_type, location),
            "type_as_constant" => type_as_constant(arguments, return_type, location),
            "type_as_integer" => type_as_integer(arguments, return_type, location),
            "type_as_slice" => type_as_slice(arguments, return_type, location),
            "type_as_str" => type_as_str(arguments, return_type, location),
            "type_as_struct" => type_as_struct(arguments, return_type, location),
            "type_as_tuple" => type_as_tuple(arguments, return_type, location),
            "type_eq" => type_eq(arguments, location),
            "type_get_trait_impl" => {
                type_get_trait_impl(interner, arguments, return_type, location)
            }
            "type_implements" => type_implements(interner, arguments, location),
            "type_is_bool" => type_is_bool(arguments, location),
            "type_is_field" => type_is_field(arguments, location),
            "type_of" => type_of(arguments, location),
            "typed_expr_as_function_definition" => {
                typed_expr_as_function_definition(interner, arguments, return_type, location)
            }
            "typed_expr_get_type" => {
                typed_expr_get_type(interner, arguments, return_type, location)
            }
            "unresolved_type_is_field" => unresolved_type_is_field(interner, arguments, location),
            "zeroed" => zeroed(return_type),
            _ => {
                let item = format!("Comptime evaluation for builtin function {name}");
                Err(InterpreterError::Unimplemented { item, location })
            }
        }
    }
}

fn failing_constraint<T>(
    message: impl Into<String>,
    location: Location,
    call_stack: &im::Vector<Location>,
) -> IResult<T> {
    Err(InterpreterError::FailingConstraint {
        message: Some(message.into()),
        location,
        call_stack: call_stack.clone(),
    })
}

fn array_len(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (argument, argument_location) = check_one_argument(arguments, location)?;

    match argument {
        Value::Array(values, _) | Value::Slice(values, _) => Ok(Value::U32(values.len() as u32)),
        value => {
            let type_var = Box::new(interner.next_type_variable());
            let expected = Type::Array(type_var.clone(), type_var);
            let actual = value.get_type().into_owned();
            Err(InterpreterError::TypeMismatch { expected, actual, location: argument_location })
        }
    }
}

fn array_as_str_unchecked(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let array = get_array(interner, argument)?.0;
    let string_bytes = try_vecmap(array, |byte| get_u8((byte, location)))?;
    let string = String::from_utf8_lossy(&string_bytes).into_owned();
    Ok(Value::String(Rc::new(string)))
}

fn as_slice(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (array, array_location) = check_one_argument(arguments, location)?;

    match array {
        Value::Array(values, Type::Array(_, typ)) => Ok(Value::Slice(values, Type::Slice(typ))),
        value => {
            let type_var = Box::new(interner.next_type_variable());
            let expected = Type::Array(type_var.clone(), type_var);
            let actual = value.get_type().into_owned();
            Err(InterpreterError::TypeMismatch { expected, actual, location: array_location })
        }
    }
}

fn slice_push_back(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (slice, (element, _)) = check_two_arguments(arguments, location)?;

    let (mut values, typ) = get_slice(interner, slice)?;
    values.push_back(element);
    Ok(Value::Slice(values, typ))
}

fn str_as_bytes(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let string = check_one_argument(arguments, location)?;
    let string = get_str(interner, string)?;

    let bytes: im::Vector<Value> = string.bytes().map(Value::U8).collect();
    let byte_array_type = Type::Array(
        Box::new(Type::Constant(bytes.len() as u32)),
        Box::new(Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight)),
    );
    Ok(Value::Array(bytes, byte_array_type))
}

// fn add_attribute<let N: u32>(self, attribute: str<N>)
fn struct_def_add_attribute(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, attribute) = check_two_arguments(arguments, location)?;
    let attribute_location = attribute.1;
    let attribute = get_str(interner, attribute)?;

    let mut tokens = Lexer::lex(&format!("#[{}]", attribute)).0 .0;
    if let Some(Token::EOF) = tokens.last().map(|token| token.token()) {
        tokens.pop();
    }
    if tokens.len() != 1 {
        return Err(InterpreterError::InvalidAttribute {
            attribute: attribute.to_string(),
            location: attribute_location,
        });
    }

    let token = tokens.into_iter().next().unwrap().into_token();
    let Token::Attribute(attribute) = token else {
        return Err(InterpreterError::InvalidAttribute {
            attribute: attribute.to_string(),
            location: attribute_location,
        });
    };

    let Attribute::Secondary(attribute) = attribute else {
        return Err(InterpreterError::InvalidAttribute {
            attribute: attribute.to_string(),
            location: attribute_location,
        });
    };

    let struct_id = get_struct(self_argument)?;
    interner.update_struct_attributes(struct_id, |attributes| {
        attributes.push(attribute.clone());
    });

    Ok(Value::Unit)
}

// fn add_generic<let N: u32>(self, generic_name: str<N>)
fn struct_def_add_generic(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, generic) = check_two_arguments(arguments, location)?;
    let generic_location = generic.1;
    let generic = get_str(interner, generic)?;

    let mut tokens = Lexer::lex(&generic).0 .0;
    if let Some(Token::EOF) = tokens.last().map(|token| token.token()) {
        tokens.pop();
    }

    if tokens.len() != 1 {
        return Err(InterpreterError::GenericNameShouldBeAnIdent {
            name: generic,
            location: generic_location,
        });
    }

    let Token::Ident(generic_name) = tokens.pop().unwrap().into_token() else {
        return Err(InterpreterError::GenericNameShouldBeAnIdent {
            name: generic,
            location: generic_location,
        });
    };

    let struct_id = get_struct(self_argument)?;
    let the_struct = interner.get_struct(struct_id);
    let mut the_struct = the_struct.borrow_mut();
    let name = Rc::new(generic_name);

    for generic in &the_struct.generics {
        if generic.name == name {
            return Err(InterpreterError::DuplicateGeneric {
                name,
                struct_name: the_struct.name.to_string(),
                existing_location: Location::new(generic.span, the_struct.location.file),
                duplicate_location: generic_location,
            });
        }
    }

    let type_var = TypeVariable::unbound(interner.next_type_variable_id());
    let span = generic_location.span;
    let kind = Kind::Normal;
    let typ = Type::NamedGeneric(type_var.clone(), name.clone(), kind.clone());
    let new_generic = ResolvedGeneric { name, type_var, span, kind };
    the_struct.generics.push(new_generic);

    Ok(Value::Type(typ))
}

/// fn as_type(self) -> Type
fn struct_def_as_type(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let struct_id = get_struct(argument)?;
    let struct_def_rc = interner.get_struct(struct_id);
    let struct_def = struct_def_rc.borrow();

    let generics = vecmap(&struct_def.generics, |generic| {
        Type::NamedGeneric(generic.type_var.clone(), generic.name.clone(), generic.kind.clone())
    });

    drop(struct_def);
    Ok(Value::Type(Type::Struct(struct_def_rc, generics)))
}

/// fn generics(self) -> [Type]
fn struct_def_generics(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let struct_id = get_struct(argument)?;
    let struct_def = interner.get_struct(struct_id);
    let struct_def = struct_def.borrow();

    let generics =
        struct_def.generics.iter().map(|generic| Value::Type(generic.clone().as_named_generic()));

    let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Type)));
    Ok(Value::Slice(generics.collect(), typ))
}

// fn has_named_attribute(self, name: Quoted) -> bool
fn struct_def_has_named_attribute(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, name) = check_two_arguments(arguments, location)?;
    let struct_id = get_struct(self_argument)?;

    let name = get_quoted(name)?;
    let name = name.iter().map(|token| token.to_string()).collect::<Vec<_>>().join("");

    let attributes = interner.struct_attributes(&struct_id);
    let attributes = attributes.iter().filter_map(|attribute| attribute.as_custom());
    let attributes = attributes.map(|attribute| &attribute.contents);

    Ok(Value::Bool(has_named_attribute(&name, attributes, location)))
}

/// fn fields(self) -> [(Quoted, Type)]
/// Returns (name, type) pairs of each field of this StructDefinition
fn struct_def_fields(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let struct_id = get_struct(argument)?;
    let struct_def = interner.get_struct(struct_id);
    let struct_def = struct_def.borrow();

    let mut fields = im::Vector::new();

    for (name, typ) in struct_def.get_fields_as_written() {
        let name = Value::Quoted(Rc::new(vec![Token::Ident(name)]));
        let typ = Value::Type(typ);
        fields.push_back(Value::Tuple(vec![name, typ]));
    }

    let typ = Type::Slice(Box::new(Type::Tuple(vec![
        Type::Quoted(QuotedType::Quoted),
        Type::Quoted(QuotedType::Type),
    ])));
    Ok(Value::Slice(fields, typ))
}

// fn module(self) -> Module
fn struct_def_module(
    interpreter: &Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let struct_id = get_struct(self_argument)?;
    let struct_module_id = struct_id.module_id();

    // A struct's module is its own module. To get the module where its defined we need
    // to look for its parent.
    let module_data = interpreter.elaborator.get_module(struct_module_id);
    let parent_local_id = module_data.parent.expect("Expected struct module parent to exist");
    let parent = ModuleId { krate: struct_module_id.krate, local_id: parent_local_id };

    Ok(Value::ModuleDefinition(parent))
}

// fn name(self) -> Quoted
fn struct_def_name(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let struct_id = get_struct(self_argument)?;
    let the_struct = interner.get_struct(struct_id);

    let name = Token::Ident(the_struct.borrow().name.to_string());
    Ok(Value::Quoted(Rc::new(vec![name])))
}

/// fn set_fields(self, new_fields: [(Quoted, Type)]) {}
/// Returns (name, type) pairs of each field of this StructDefinition
fn struct_def_set_fields(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (the_struct, fields) = check_two_arguments(arguments, location)?;
    let struct_id = get_struct(the_struct)?;

    let struct_def = interner.get_struct(struct_id);
    let mut struct_def = struct_def.borrow_mut();

    let field_location = fields.1;
    let fields = get_slice(interner, fields)?.0;

    let new_fields = fields
        .into_iter()
        .flat_map(|field_pair| get_tuple(interner, (field_pair, field_location)))
        .enumerate()
        .map(|(index, mut field_pair)| {
            if field_pair.len() == 2 {
                let typ = field_pair.pop().unwrap();
                let name_value = field_pair.pop().unwrap();

                let name_tokens = get_quoted((name_value.clone(), field_location))?;
                let typ = get_type((typ, field_location))?;

                match name_tokens.first() {
                    Some(Token::Ident(name)) if name_tokens.len() == 1 => {
                        Ok((Ident::new(name.clone(), field_location.span), typ))
                    }
                    _ => {
                        let value = name_value.display(interner).to_string();
                        let location = field_location;
                        Err(InterpreterError::ExpectedIdentForStructField {
                            value,
                            index,
                            location,
                        })
                    }
                }
            } else {
                let type_var = interner.next_type_variable();
                let expected = Type::Tuple(vec![type_var.clone(), type_var]);

                let actual =
                    Type::Tuple(vecmap(&field_pair, |value| value.get_type().into_owned()));

                Err(InterpreterError::TypeMismatch { expected, actual, location })
            }
        })
        .collect::<Result<Vec<_>, _>>()?;

    struct_def.set_fields(new_fields);
    Ok(Value::Unit)
}

fn slice_remove(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
    call_stack: &im::Vector<Location>,
) -> IResult<Value> {
    let (slice, index) = check_two_arguments(arguments, location)?;

    let (mut values, typ) = get_slice(interner, slice)?;
    let index = get_u32(index)? as usize;

    if values.is_empty() {
        return failing_constraint("slice_remove called on empty slice", location, call_stack);
    }

    if index >= values.len() {
        let message = format!(
            "slice_remove: index {index} is out of bounds for a slice of length {}",
            values.len()
        );
        return failing_constraint(message, location, call_stack);
    }

    let element = values.remove(index);
    Ok(Value::Tuple(vec![Value::Slice(values, typ), element]))
}

fn slice_push_front(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (slice, (element, _)) = check_two_arguments(arguments, location)?;

    let (mut values, typ) = get_slice(interner, slice)?;
    values.push_front(element);
    Ok(Value::Slice(values, typ))
}

fn slice_pop_front(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
    call_stack: &im::Vector<Location>,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let (mut values, typ) = get_slice(interner, argument)?;
    match values.pop_front() {
        Some(element) => Ok(Value::Tuple(vec![element, Value::Slice(values, typ)])),
        None => failing_constraint("slice_pop_front called on empty slice", location, call_stack),
    }
}

fn slice_pop_back(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
    call_stack: &im::Vector<Location>,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let (mut values, typ) = get_slice(interner, argument)?;
    match values.pop_back() {
        Some(element) => Ok(Value::Tuple(vec![Value::Slice(values, typ), element])),
        None => failing_constraint("slice_pop_back called on empty slice", location, call_stack),
    }
}

fn slice_insert(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (slice, index, (element, _)) = check_three_arguments(arguments, location)?;

    let (mut values, typ) = get_slice(interner, slice)?;
    let index = get_u32(index)? as usize;
    values.insert(index, element);
    Ok(Value::Slice(values, typ))
}

// fn as_expr(quoted: Quoted) -> Option<Expr>
fn quoted_as_expr(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let expr_parser = parser::expression().map(|expr| Value::expression(expr.kind));
    let statement_parser = parser::fresh_statement().map(Value::statement);
    let lvalue_parser = parser::lvalue(parser::expression()).map(Value::lvalue);
    let parser = choice((expr_parser, statement_parser, lvalue_parser));

    let expr = parse(argument, parser, "an expression").ok();

    option(return_type, expr)
}

// fn as_module(quoted: Quoted) -> Option<Module>
fn quoted_as_module(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let path = parse(argument, parser::path_no_turbofish(), "a path").ok();
    let option_value = path.and_then(|path| {
        let module = interpreter
            .elaborate_in_function(interpreter.current_function, |elaborator| {
                elaborator.resolve_module_by_path(path)
            });
        module.map(Value::ModuleDefinition)
    });

    option(return_type, option_value)
}

// fn as_trait_constraint(quoted: Quoted) -> TraitConstraint
fn quoted_as_trait_constraint(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let trait_bound = parse(argument, parser::trait_bound(), "a trait constraint")?;
    let bound = interpreter
        .elaborate_in_function(interpreter.current_function, |elaborator| {
            elaborator.resolve_trait_bound(&trait_bound, Type::Unit)
        })
        .ok_or(InterpreterError::FailedToResolveTraitBound { trait_bound, location })?;

    Ok(Value::TraitConstraint(bound.trait_id, bound.trait_generics))
}

// fn as_type(quoted: Quoted) -> Type
fn quoted_as_type(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let typ = parse(argument, parser::parse_type(), "a type")?;
    let typ = interpreter
        .elaborate_in_function(interpreter.current_function, |elab| elab.resolve_type(typ));
    Ok(Value::Type(typ))
}

// fn tokens(quoted: Quoted) -> [Quoted]
fn quoted_tokens(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;
    let value = get_quoted(argument)?;

    Ok(Value::Slice(
        value.iter().map(|token| Value::Quoted(Rc::new(vec![token.clone()]))).collect(),
        Type::Slice(Box::new(Type::Quoted(QuotedType::Quoted))),
    ))
}

fn to_le_radix(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let (value, radix) = check_two_arguments(arguments, location)?;

    let value = get_field(value)?;
    let radix = get_u32(radix)?;
    let limb_count = if let Type::Array(length, _) = return_type {
        if let Type::Constant(limb_count) = *length {
            limb_count
        } else {
            return Err(InterpreterError::TypeAnnotationsNeededForMethodCall { location });
        }
    } else {
        return Err(InterpreterError::TypeAnnotationsNeededForMethodCall { location });
    };

    // Decompose the integer into its radix digits in little endian form.
    let decomposed_integer = compute_to_radix(value, radix);
    let decomposed_integer = vecmap(0..limb_count as usize, |i| match decomposed_integer.get(i) {
        Some(digit) => Value::U8(*digit),
        None => Value::U8(0),
    });
    Ok(Value::Array(
        decomposed_integer.into(),
        Type::Integer(Signedness::Unsigned, IntegerBitSize::Eight),
    ))
}

fn compute_to_radix(field: FieldElement, radix: u32) -> Vec<u8> {
    let bit_size = u32::BITS - (radix - 1).leading_zeros();
    let radix_big = BigUint::from(radix);
    assert_eq!(BigUint::from(2u128).pow(bit_size), radix_big, "ICE: Radix must be a power of 2");
    let big_integer = BigUint::from_bytes_be(&field.to_be_bytes());

    // Decompose the integer into its radix digits in little endian form.
    big_integer.to_radix_le(radix)
}

// fn as_array(self) -> Option<(Type, Type)>
fn type_as_array(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        if let Type::Array(length, array_type) = typ {
            Some(Value::Tuple(vec![Value::Type(*array_type), Value::Type(*length)]))
        } else {
            None
        }
    })
}

// fn as_constant(self) -> Option<u32>
fn type_as_constant(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        // Prefer to use `evaluate_to_u32` over matching on `Type::Constant`
        // since arithmetic generics may be `Type::InfixExpr`s which evaluate to
        // constants but are not actually the `Type::Constant` variant.
        typ.evaluate_to_u32().map(Value::U32)
    })
}

// fn as_integer(self) -> Option<(bool, u8)>
fn type_as_integer(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        if let Type::Integer(sign, bits) = typ {
            Some(Value::Tuple(vec![Value::Bool(sign.is_signed()), Value::U8(bits.bit_size())]))
        } else {
            None
        }
    })
}

// fn as_slice(self) -> Option<Type>
fn type_as_slice(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        if let Type::Slice(slice_type) = typ {
            Some(Value::Type(*slice_type))
        } else {
            None
        }
    })
}

// fn as_str(self) -> Option<Type>
fn type_as_str(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        if let Type::String(n) = typ {
            Some(Value::Type(*n))
        } else {
            None
        }
    })
}

// fn as_struct(self) -> Option<(StructDefinition, [Type])>
fn type_as_struct(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type, location, |typ| {
        if let Type::Struct(struct_type, generics) = typ {
            Some(Value::Tuple(vec![
                Value::StructDefinition(struct_type.borrow().id),
                Value::Slice(
                    generics.into_iter().map(Value::Type).collect(),
                    Type::Slice(Box::new(Type::Quoted(QuotedType::Type))),
                ),
            ]))
        } else {
            None
        }
    })
}

// fn as_tuple(self) -> Option<[Type]>
fn type_as_tuple(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    type_as(arguments, return_type.clone(), location, |typ| {
        if let Type::Tuple(types) = typ {
            let t = extract_option_generic_type(return_type);

            let Type::Slice(slice_type) = t else {
                panic!("Expected T to be a slice");
            };

            Some(Value::Slice(types.into_iter().map(Value::Type).collect(), *slice_type))
        } else {
            None
        }
    })
}

// Helper function for implementing the `type_as_...` functions.
fn type_as<F>(
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
    f: F,
) -> IResult<Value>
where
    F: FnOnce(Type) -> Option<Value>,
{
    let value = check_one_argument(arguments, location)?;
    let typ = get_type(value)?.follow_bindings();

    let option_value = f(typ);

    option(return_type, option_value)
}

// fn type_eq(_first: Type, _second: Type) -> bool
fn type_eq(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let (self_type, other_type) = check_two_arguments(arguments, location)?;

    let self_type = get_type(self_type)?;
    let other_type = get_type(other_type)?;

    Ok(Value::Bool(self_type == other_type))
}

// fn get_trait_impl(self, constraint: TraitConstraint) -> Option<TraitImpl>
fn type_get_trait_impl(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let (typ, constraint) = check_two_arguments(arguments, location)?;

    let typ = get_type(typ)?;
    let (trait_id, generics) = get_trait_constraint(constraint)?;

    let option_value = match interner.lookup_trait_implementation(
        &typ,
        trait_id,
        &generics.ordered,
        &generics.named,
    ) {
        Ok(TraitImplKind::Normal(trait_impl_id)) => Some(Value::TraitImpl(trait_impl_id)),
        _ => None,
    };

    option(return_type, option_value)
}

// fn implements(self, constraint: TraitConstraint) -> bool
fn type_implements(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (typ, constraint) = check_two_arguments(arguments, location)?;

    let typ = get_type(typ)?;
    let (trait_id, generics) = get_trait_constraint(constraint)?;

    let implements = interner
        .lookup_trait_implementation(&typ, trait_id, &generics.ordered, &generics.named)
        .is_ok();
    Ok(Value::Bool(implements))
}

// fn is_bool(self) -> bool
fn type_is_bool(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let value = check_one_argument(arguments, location)?;
    let typ = get_type(value)?;

    Ok(Value::Bool(matches!(typ, Type::Bool)))
}

// fn is_field(self) -> bool
fn type_is_field(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let value = check_one_argument(arguments, location)?;
    let typ = get_type(value)?;

    Ok(Value::Bool(matches!(typ, Type::FieldElement)))
}

// fn type_of<T>(x: T) -> Type
fn type_of(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let (value, _) = check_one_argument(arguments, location)?;
    let typ = value.get_type().into_owned();
    Ok(Value::Type(typ))
}

// fn constraint_hash(constraint: TraitConstraint) -> Field
fn trait_constraint_hash(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let bound = get_trait_constraint(argument)?;

    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    bound.hash(&mut hasher);
    let hash = hasher.finish();

    Ok(Value::Field((hash as u128).into()))
}

// fn constraint_eq(constraint_a: TraitConstraint, constraint_b: TraitConstraint) -> bool
fn trait_constraint_eq(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (value_a, value_b) = check_two_arguments(arguments, location)?;

    let constraint_a = get_trait_constraint(value_a)?;
    let constraint_b = get_trait_constraint(value_b)?;

    Ok(Value::Bool(constraint_a == constraint_b))
}

// fn trait_def_hash(def: TraitDefinition) -> Field
fn trait_def_hash(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let id = get_trait_def(argument)?;

    let mut hasher = std::collections::hash_map::DefaultHasher::new();
    id.hash(&mut hasher);
    let hash = hasher.finish();

    Ok(Value::Field((hash as u128).into()))
}

// fn trait_def_eq(def_a: TraitDefinition, def_b: TraitDefinition) -> bool
fn trait_def_eq(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (id_a, id_b) = check_two_arguments(arguments, location)?;

    let id_a = get_trait_def(id_a)?;
    let id_b = get_trait_def(id_b)?;

    Ok(Value::Bool(id_a == id_b))
}

// fn methods(self) -> [FunctionDefinition]
fn trait_impl_methods(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let trait_impl_id = get_trait_impl(argument)?;
    let trait_impl = interner.get_trait_implementation(trait_impl_id);
    let trait_impl = trait_impl.borrow();
    let methods =
        trait_impl.methods.iter().map(|func_id| Value::FunctionDefinition(*func_id)).collect();
    let slice_type = Type::Slice(Box::new(Type::Quoted(QuotedType::FunctionDefinition)));

    Ok(Value::Slice(methods, slice_type))
}

// fn trait_generic_args(self) -> [Type]
fn trait_impl_trait_generic_args(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let argument = check_one_argument(arguments, location)?;

    let trait_impl_id = get_trait_impl(argument)?;
    let trait_impl = interner.get_trait_implementation(trait_impl_id);
    let trait_impl = trait_impl.borrow();
    let trait_generics = trait_impl.trait_generics.iter().map(|t| Value::Type(t.clone())).collect();
    let slice_type = Type::Slice(Box::new(Type::Quoted(QuotedType::Type)));

    Ok(Value::Slice(trait_generics, slice_type))
}

// fn as_function_definition(self) -> Option<FunctionDefinition>
fn typed_expr_as_function_definition(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let typed_expr = get_typed_expr(self_argument)?;
    let option_value = if let TypedExpr::ExprId(expr_id) = typed_expr {
        let func_id = interner.lookup_function_from_expr(&expr_id);
        func_id.map(Value::FunctionDefinition)
    } else {
        None
    };
    option(return_type, option_value)
}

// fn get_type(self) -> Option<Type>
fn typed_expr_get_type(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let typed_expr = get_typed_expr(self_argument)?;
    let option_value = if let TypedExpr::ExprId(expr_id) = typed_expr {
        let typ = interner.id_type(expr_id);
        if typ == Type::Error {
            None
        } else {
            Some(Value::Type(typ))
        }
    } else {
        None
    };
    option(return_type, option_value)
}

// fn is_field(self) -> bool
fn unresolved_type_is_field(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let typ = get_unresolved_type(interner, self_argument)?;
    Ok(Value::Bool(matches!(typ, UnresolvedTypeData::FieldElement)))
}

// fn zeroed<T>() -> T
fn zeroed(return_type: Type) -> IResult<Value> {
    match return_type {
        Type::FieldElement => Ok(Value::Field(0u128.into())),
        Type::Array(length_type, elem) => {
            if let Some(length) = length_type.evaluate_to_u32() {
                let element = zeroed(elem.as_ref().clone())?;
                let array = std::iter::repeat(element).take(length as usize).collect();
                Ok(Value::Array(array, Type::Array(length_type, elem)))
            } else {
                // Assume we can resolve the length later
                Ok(Value::Zeroed(Type::Array(length_type, elem)))
            }
        }
        Type::Slice(_) => Ok(Value::Slice(im::Vector::new(), return_type)),
        Type::Integer(sign, bits) => match (sign, bits) {
            (Signedness::Unsigned, IntegerBitSize::One) => Ok(Value::U8(0)),
            (Signedness::Unsigned, IntegerBitSize::Eight) => Ok(Value::U8(0)),
            (Signedness::Unsigned, IntegerBitSize::Sixteen) => Ok(Value::U16(0)),
            (Signedness::Unsigned, IntegerBitSize::ThirtyTwo) => Ok(Value::U32(0)),
            (Signedness::Unsigned, IntegerBitSize::SixtyFour) => Ok(Value::U64(0)),
            (Signedness::Signed, IntegerBitSize::One) => Ok(Value::I8(0)),
            (Signedness::Signed, IntegerBitSize::Eight) => Ok(Value::I8(0)),
            (Signedness::Signed, IntegerBitSize::Sixteen) => Ok(Value::I16(0)),
            (Signedness::Signed, IntegerBitSize::ThirtyTwo) => Ok(Value::I32(0)),
            (Signedness::Signed, IntegerBitSize::SixtyFour) => Ok(Value::I64(0)),
        },
        Type::Bool => Ok(Value::Bool(false)),
        Type::String(length_type) => {
            if let Some(length) = length_type.evaluate_to_u32() {
                Ok(Value::String(Rc::new("\0".repeat(length as usize))))
            } else {
                // Assume we can resolve the length later
                Ok(Value::Zeroed(Type::String(length_type)))
            }
        }
        Type::FmtString(length_type, captures) => {
            let length = length_type.evaluate_to_u32();
            let typ = Type::FmtString(length_type, captures);
            if let Some(length) = length {
                Ok(Value::FormatString(Rc::new("\0".repeat(length as usize)), typ))
            } else {
                // Assume we can resolve the length later
                Ok(Value::Zeroed(typ))
            }
        }
        Type::Unit => Ok(Value::Unit),
        Type::Tuple(fields) => Ok(Value::Tuple(try_vecmap(fields, zeroed)?)),
        Type::Struct(struct_type, generics) => {
            let fields = struct_type.borrow().get_fields(&generics);
            let mut values = HashMap::default();

            for (field_name, field_type) in fields {
                let field_value = zeroed(field_type)?;
                values.insert(Rc::new(field_name), field_value);
            }

            let typ = Type::Struct(struct_type, generics);
            Ok(Value::Struct(values, typ))
        }
        Type::Alias(alias, generics) => zeroed(alias.borrow().get_type(&generics)),
        typ @ Type::Function(..) => {
            // Using Value::Zeroed here is probably safer than using FuncId::dummy_id() or similar
            Ok(Value::Zeroed(typ))
        }
        Type::MutableReference(element) => {
            let element = zeroed(*element)?;
            Ok(Value::Pointer(Shared::new(element), false))
        }
        // Optimistically assume we can resolve this type later or that the value is unused
        Type::TypeVariable(_, _)
        | Type::Forall(_, _)
        | Type::Constant(_)
        | Type::InfixExpr(..)
        | Type::Quoted(_)
        | Type::Error
        | Type::TraitAsType(..)
        | Type::NamedGeneric(_, _, _) => Ok(Value::Zeroed(return_type)),
    }
}

// fn as_array(self) -> Option<[Expr]>
fn expr_as_array(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Literal(Literal::Array(
            ArrayLiteral::Standard(exprs),
        ))) = expr
        {
            let exprs = exprs.into_iter().map(|expr| Value::expression(expr.kind)).collect();
            let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Expr)));
            Some(Value::Slice(exprs, typ))
        } else {
            None
        }
    })
}

// fn as_assert(self) -> Option<(Expr, Option<Expr>)>
fn expr_as_assert(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| {
        if let ExprValue::Statement(StatementKind::Constrain(constrain)) = expr {
            if constrain.2 == ConstrainKind::Assert {
                let predicate = Value::expression(constrain.0.kind);

                let option_type = extract_option_generic_type(return_type);
                let Type::Tuple(mut tuple_types) = option_type else {
                    panic!("Expected the return type option generic arg to be a tuple");
                };
                assert_eq!(tuple_types.len(), 2);

                let option_type = tuple_types.pop().unwrap();
                let message = constrain.1.map(|message| Value::expression(message.kind));
                let message = option(option_type, message).ok()?;

                Some(Value::Tuple(vec![predicate, message]))
            } else {
                None
            }
        } else {
            None
        }
    })
}

// fn as_assert_eq(self) -> Option<(Expr, Expr, Option<Expr>)>
fn expr_as_assert_eq(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| {
        if let ExprValue::Statement(StatementKind::Constrain(constrain)) = expr {
            if constrain.2 == ConstrainKind::AssertEq {
                let ExpressionKind::Infix(infix) = constrain.0.kind else {
                    panic!("Expected AssertEq constrain statement to have an infix expression");
                };

                let lhs = Value::expression(infix.lhs.kind);
                let rhs = Value::expression(infix.rhs.kind);

                let option_type = extract_option_generic_type(return_type);
                let Type::Tuple(mut tuple_types) = option_type else {
                    panic!("Expected the return type option generic arg to be a tuple");
                };
                assert_eq!(tuple_types.len(), 3);

                let option_type = tuple_types.pop().unwrap();
                let message = constrain.1.map(|message| Value::expression(message.kind));
                let message = option(option_type, message).ok()?;

                Some(Value::Tuple(vec![lhs, rhs, message]))
            } else {
                None
            }
        } else {
            None
        }
    })
}

// fn as_assign(self) -> Option<(Expr, Expr)>
fn expr_as_assign(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Statement(StatementKind::Assign(assign)) = expr {
            let lhs = Value::lvalue(assign.lvalue);
            let rhs = Value::expression(assign.expression.kind);
            Some(Value::Tuple(vec![lhs, rhs]))
        } else {
            None
        }
    })
}

// fn as_binary_op(self) -> Option<(Expr, BinaryOp, Expr)>
fn expr_as_binary_op(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Infix(infix_expr)) = expr {
            let option_type = extract_option_generic_type(return_type);
            let Type::Tuple(mut tuple_types) = option_type else {
                panic!("Expected the return type option generic arg to be a tuple");
            };
            assert_eq!(tuple_types.len(), 3);

            tuple_types.pop().unwrap();
            let binary_op_type = tuple_types.pop().unwrap();

            // For the op value we use the enum member index, which should match noir_stdlib/src/meta/op.nr
            let binary_op_value = infix_expr.operator.contents as u128;

            let mut fields = HashMap::default();
            fields.insert(Rc::new("op".to_string()), Value::Field(binary_op_value.into()));

            let unary_op = Value::Struct(fields, binary_op_type);
            let lhs = Value::expression(infix_expr.lhs.kind);
            let rhs = Value::expression(infix_expr.rhs.kind);
            Some(Value::Tuple(vec![lhs, unary_op, rhs]))
        } else {
            None
        }
    })
}

// fn as_block(self) -> Option<[Expr]>
fn expr_as_block(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Block(block_expr)) = expr {
            Some(block_expression_to_value(block_expr))
        } else {
            None
        }
    })
}

// fn as_bool(self) -> Option<bool>
fn expr_as_bool(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Literal(Literal::Bool(bool))) = expr {
            Some(Value::Bool(bool))
        } else {
            None
        }
    })
}

// fn as_cast(self) -> Option<(Expr, UnresolvedType)>
fn expr_as_cast(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Cast(cast)) = expr {
            let lhs = Value::expression(cast.lhs.kind);
            let typ = Value::UnresolvedType(cast.r#type.typ);
            Some(Value::Tuple(vec![lhs, typ]))
        } else {
            None
        }
    })
}

// fn as_comptime(self) -> Option<[Expr]>
fn expr_as_comptime(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    use ExpressionKind::Block;

    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Comptime(block_expr, _)) = expr {
            Some(block_expression_to_value(block_expr))
        } else if let ExprValue::Statement(StatementKind::Comptime(statement)) = expr {
            let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Expr)));

            // comptime { ... } as a statement wraps a block expression,
            // and in that case we return the block expression statements
            // (comptime as a statement can also be comptime for, but in that case we'll
            // return the for statement as a single expression)
            if let StatementKind::Expression(Expression { kind: Block(block), .. }) = statement.kind
            {
                Some(block_expression_to_value(block))
            } else {
                let mut elements = Vector::new();
                elements.push_back(Value::statement(statement.kind));
                Some(Value::Slice(elements, typ))
            }
        } else {
            None
        }
    })
}

// fn as_function_call(self) -> Option<(Expr, [Expr])>
fn expr_as_function_call(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Call(call_expression)) = expr {
            let function = Value::expression(call_expression.func.kind);
            let arguments = call_expression.arguments.into_iter();
            let arguments = arguments.map(|argument| Value::expression(argument.kind)).collect();
            let arguments =
                Value::Slice(arguments, Type::Slice(Box::new(Type::Quoted(QuotedType::Expr))));
            Some(Value::Tuple(vec![function, arguments]))
        } else {
            None
        }
    })
}

// fn as_if(self) -> Option<(Expr, Expr, Option<Expr>)>
fn expr_as_if(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| {
        if let ExprValue::Expression(ExpressionKind::If(if_expr)) = expr {
            // Get the type of `Option<Expr>`
            let option_type = extract_option_generic_type(return_type.clone());
            let Type::Tuple(option_types) = option_type else {
                panic!("Expected the return type option generic arg to be a tuple");
            };
            assert_eq!(option_types.len(), 3);
            let alternative_option_type = option_types[2].clone();

            let alternative = option(
                alternative_option_type,
                if_expr.alternative.map(|e| Value::expression(e.kind)),
            );

            Some(Value::Tuple(vec![
                Value::expression(if_expr.condition.kind),
                Value::expression(if_expr.consequence.kind),
                alternative.ok()?,
            ]))
        } else {
            None
        }
    })
}

// fn as_index(self) -> Option<Expr>
fn expr_as_index(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Index(index_expr)) = expr {
            Some(Value::Tuple(vec![
                Value::expression(index_expr.collection.kind),
                Value::expression(index_expr.index.kind),
            ]))
        } else {
            None
        }
    })
}

// fn as_integer(self) -> Option<(Field, bool)>
fn expr_as_integer(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| match expr {
        ExprValue::Expression(ExpressionKind::Literal(Literal::Integer(field, sign))) => {
            Some(Value::Tuple(vec![Value::Field(field), Value::Bool(sign)]))
        }
        ExprValue::Expression(ExpressionKind::Resolved(id)) => {
            if let HirExpression::Literal(HirLiteral::Integer(field, sign)) =
                interner.expression(&id)
            {
                Some(Value::Tuple(vec![Value::Field(field), Value::Bool(sign)]))
            } else {
                None
            }
        }
        _ => None,
    })
}

// fn as_let(self) -> Option<(Expr, Option<UnresolvedType>, Expr)>
fn expr_as_let(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| match expr {
        ExprValue::Statement(StatementKind::Let(let_statement)) => {
            let option_type = extract_option_generic_type(return_type);
            let Type::Tuple(mut tuple_types) = option_type else {
                panic!("Expected the return type option generic arg to be a tuple");
            };
            assert_eq!(tuple_types.len(), 3);
            tuple_types.pop().unwrap();
            let option_type = tuple_types.pop().unwrap();

            let typ = if let_statement.r#type.typ == UnresolvedTypeData::Unspecified {
                None
            } else {
                Some(Value::UnresolvedType(let_statement.r#type.typ))
            };

            let typ = option(option_type, typ).ok()?;

            Some(Value::Tuple(vec![
                Value::pattern(let_statement.pattern),
                typ,
                Value::expression(let_statement.expression.kind),
            ]))
        }
        _ => None,
    })
}

// fn as_member_access(self) -> Option<(Expr, Quoted)>
fn expr_as_member_access(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| match expr {
        ExprValue::Expression(ExpressionKind::MemberAccess(member_access)) => {
            let tokens = Rc::new(vec![Token::Ident(member_access.rhs.0.contents.clone())]);
            Some(Value::Tuple(vec![
                Value::expression(member_access.lhs.kind),
                Value::Quoted(tokens),
            ]))
        }
        ExprValue::LValue(crate::ast::LValue::MemberAccess { object, field_name, span: _ }) => {
            let tokens = Rc::new(vec![Token::Ident(field_name.0.contents.clone())]);
            Some(Value::Tuple(vec![Value::lvalue(*object), Value::Quoted(tokens)]))
        }
        _ => None,
    })
}

// fn as_method_call(self) -> Option<(Expr, Quoted, [UnresolvedType], [Expr])>
fn expr_as_method_call(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::MethodCall(method_call)) = expr {
            let object = Value::expression(method_call.object.kind);

            let name_tokens =
                Rc::new(vec![Token::Ident(method_call.method_name.0.contents.clone())]);
            let name = Value::Quoted(name_tokens);

            let generics = method_call.generics.unwrap_or_default().into_iter();
            let generics = generics.map(|generic| Value::UnresolvedType(generic.typ)).collect();
            let generics = Value::Slice(
                generics,
                Type::Slice(Box::new(Type::Quoted(QuotedType::UnresolvedType))),
            );

            let arguments = method_call.arguments.into_iter();
            let arguments = arguments.map(|argument| Value::expression(argument.kind)).collect();
            let arguments =
                Value::Slice(arguments, Type::Slice(Box::new(Type::Quoted(QuotedType::Expr))));

            Some(Value::Tuple(vec![object, name, generics, arguments]))
        } else {
            None
        }
    })
}

// fn as_repeated_element_array(self) -> Option<(Expr, Expr)>
fn expr_as_repeated_element_array(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Literal(Literal::Array(
            ArrayLiteral::Repeated { repeated_element, length },
        ))) = expr
        {
            Some(Value::Tuple(vec![
                Value::expression(repeated_element.kind),
                Value::expression(length.kind),
            ]))
        } else {
            None
        }
    })
}

// fn as_repeated_element_slice(self) -> Option<(Expr, Expr)>
fn expr_as_repeated_element_slice(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Literal(Literal::Slice(
            ArrayLiteral::Repeated { repeated_element, length },
        ))) = expr
        {
            Some(Value::Tuple(vec![
                Value::expression(repeated_element.kind),
                Value::expression(length.kind),
            ]))
        } else {
            None
        }
    })
}

// fn as_slice(self) -> Option<[Expr]>
fn expr_as_slice(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Literal(Literal::Slice(
            ArrayLiteral::Standard(exprs),
        ))) = expr
        {
            let exprs = exprs.into_iter().map(|expr| Value::expression(expr.kind)).collect();
            let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Expr)));
            Some(Value::Slice(exprs, typ))
        } else {
            None
        }
    })
}

// fn as_tuple(self) -> Option<[Expr]>
fn expr_as_tuple(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Tuple(expressions)) = expr {
            let expressions =
                expressions.into_iter().map(|expr| Value::expression(expr.kind)).collect();
            let typ = Type::Slice(Box::new(Type::Quoted(QuotedType::Expr)));
            Some(Value::Slice(expressions, typ))
        } else {
            None
        }
    })
}

// fn as_unary_op(self) -> Option<(UnaryOp, Expr)>
fn expr_as_unary_op(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type.clone(), location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Prefix(prefix_expr)) = expr {
            let option_type = extract_option_generic_type(return_type);
            let Type::Tuple(mut tuple_types) = option_type else {
                panic!("Expected the return type option generic arg to be a tuple");
            };
            assert_eq!(tuple_types.len(), 2);

            tuple_types.pop().unwrap();
            let unary_op_type = tuple_types.pop().unwrap();

            // These values should match the values used in noir_stdlib/src/meta/op.nr
            let unary_op_value: u128 = match prefix_expr.operator {
                UnaryOp::Minus => 0,
                UnaryOp::Not => 1,
                UnaryOp::MutableReference => 2,
                UnaryOp::Dereference { .. } => 3,
            };

            let mut fields = HashMap::default();
            fields.insert(Rc::new("op".to_string()), Value::Field(unary_op_value.into()));

            let unary_op = Value::Struct(fields, unary_op_type);
            let rhs = Value::expression(prefix_expr.rhs.kind);
            Some(Value::Tuple(vec![unary_op, rhs]))
        } else {
            None
        }
    })
}

// fn as_unsafe(self) -> Option<[Expr]>
fn expr_as_unsafe(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
) -> IResult<Value> {
    expr_as(interner, arguments, return_type, location, |expr| {
        if let ExprValue::Expression(ExpressionKind::Unsafe(block_expr, _)) = expr {
            Some(block_expression_to_value(block_expr))
        } else {
            None
        }
    })
}

// fn as_has_semicolon(self) -> bool
fn expr_has_semicolon(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let expr_value = get_expr(interner, self_argument)?;
    Ok(Value::Bool(matches!(expr_value, ExprValue::Statement(StatementKind::Semi(..)))))
}

// fn is_break(self) -> bool
fn expr_is_break(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let expr_value = get_expr(interner, self_argument)?;
    Ok(Value::Bool(matches!(expr_value, ExprValue::Statement(StatementKind::Break))))
}

// fn is_continue(self) -> bool
fn expr_is_continue(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let expr_value = get_expr(interner, self_argument)?;
    Ok(Value::Bool(matches!(expr_value, ExprValue::Statement(StatementKind::Continue))))
}

// Helper function for implementing the `expr_as_...` functions.
fn expr_as<F>(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    return_type: Type,
    location: Location,
    f: F,
) -> IResult<Value>
where
    F: FnOnce(ExprValue) -> Option<Value>,
{
    let self_argument = check_one_argument(arguments, location)?;
    let expr_value = get_expr(interner, self_argument)?;
    let expr_value = unwrap_expr_value(interner, expr_value);

    let option_value = f(expr_value);
    option(return_type, option_value)
}

// fn resolve(self, in_function: Option<FunctionDefinition>) -> TypedExpr
fn expr_resolve(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, func) = check_two_arguments(arguments, location)?;
    let self_argument_location = self_argument.1;
    let expr_value = get_expr(interpreter.elaborator.interner, self_argument)?;
    let expr_value = unwrap_expr_value(interpreter.elaborator.interner, expr_value);

    let Value::Struct(fields, _) = func.0 else {
        panic!("Expected second argument to be a struct");
    };

    let is_some = fields.get(&Rc::new("_is_some".to_string())).unwrap();
    let Value::Bool(is_some) = is_some else {
        panic!("Expected is_some to be a boolean");
    };

    let function_to_resolve_in = if *is_some {
        let value = fields.get(&Rc::new("_value".to_string())).unwrap();
        let Value::FunctionDefinition(func_id) = value else {
            panic!("Expected option value to be a FunctionDefinition");
        };
        Some(*func_id)
    } else {
        interpreter.current_function
    };

    interpreter.elaborate_in_function(function_to_resolve_in, |elaborator| match expr_value {
        ExprValue::Expression(expression_kind) => {
            let expr = Expression { kind: expression_kind, span: self_argument_location.span };
            let (expr_id, _) = elaborator.elaborate_expression(expr);
            Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
        }
        ExprValue::Statement(statement_kind) => {
            let statement = Statement { kind: statement_kind, span: self_argument_location.span };
            let (stmt_id, _) = elaborator.elaborate_statement(statement);
            Ok(Value::TypedExpr(TypedExpr::StmtId(stmt_id)))
        }
        ExprValue::LValue(lvalue) => {
            let expr = lvalue.as_expression();
            let (expr_id, _) = elaborator.elaborate_expression(expr);
            Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
        }
        ExprValue::Pattern(pattern) => {
            if let Some(expression) = pattern.try_as_expression(elaborator.interner) {
                let (expr_id, _) = elaborator.elaborate_expression(expression);
                Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
            } else {
                let expression = Value::pattern(pattern).display(elaborator.interner).to_string();
                let location = self_argument_location;
                Err(InterpreterError::CannotResolveExpression { location, expression })
            }
        }
    })
}

fn unwrap_expr_value(interner: &NodeInterner, mut expr_value: ExprValue) -> ExprValue {
    loop {
        match expr_value {
            ExprValue::Expression(ExpressionKind::Parenthesized(expression)) => {
                expr_value = ExprValue::Expression(expression.kind);
            }
            ExprValue::Statement(StatementKind::Expression(expression))
            | ExprValue::Statement(StatementKind::Semi(expression)) => {
                expr_value = ExprValue::Expression(expression.kind);
            }
            ExprValue::Expression(ExpressionKind::Interned(id)) => {
                expr_value = ExprValue::Expression(interner.get_expression_kind(id).clone());
            }
            ExprValue::Statement(StatementKind::Interned(id)) => {
                expr_value = ExprValue::Statement(interner.get_statement_kind(id).clone());
            }
            ExprValue::LValue(LValue::Interned(id, span)) => {
                expr_value = ExprValue::LValue(interner.get_lvalue(id, span).clone());
            }
            ExprValue::Pattern(Pattern::Interned(id, _)) => {
                expr_value = ExprValue::Pattern(interner.get_pattern(id).clone());
            }
            _ => break,
        }
    }
    expr_value
}

// fn quoted_contents(self) -> Quoted
fn fmtstr_quoted_contents(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let (string, _) = get_format_string(interner, self_argument)?;
    let (tokens, _) = Lexer::lex(&string);
    let mut tokens: Vec<_> = tokens.0.into_iter().map(|token| token.into_token()).collect();
    if let Some(Token::EOF) = tokens.last() {
        tokens.pop();
    }

    Ok(Value::Quoted(Rc::new(tokens)))
}

// fn fresh_type_variable() -> Type
fn fresh_type_variable(interner: &NodeInterner) -> IResult<Value> {
    Ok(Value::Type(interner.next_type_variable()))
}

// fn add_attribute<let N: u32>(self, attribute: str<N>)
fn function_def_add_attribute(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, attribute) = check_two_arguments(arguments, location)?;
    let attribute_location = attribute.1;
    let attribute = get_str(interpreter.elaborator.interner, attribute)?;

    let mut tokens = Lexer::lex(&format!("#[{}]", attribute)).0 .0;
    if let Some(Token::EOF) = tokens.last().map(|token| token.token()) {
        tokens.pop();
    }
    if tokens.len() != 1 {
        return Err(InterpreterError::InvalidAttribute {
            attribute: attribute.to_string(),
            location: attribute_location,
        });
    }

    let token = tokens.into_iter().next().unwrap().into_token();
    let Token::Attribute(attribute) = token else {
        return Err(InterpreterError::InvalidAttribute {
            attribute: attribute.to_string(),
            location: attribute_location,
        });
    };

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let function_modifiers = interpreter.elaborator.interner.function_modifiers_mut(&func_id);

    match &attribute {
        Attribute::Function(attribute) => {
            function_modifiers.attributes.function = Some(attribute.clone());
        }
        Attribute::Secondary(attribute) => {
            function_modifiers.attributes.secondary.push(attribute.clone());
        }
    }

    if let Attribute::Secondary(SecondaryAttribute::Custom(attribute)) = attribute {
        let func_meta = interpreter.elaborator.interner.function_meta_mut(&func_id);
        func_meta.custom_attributes.push(attribute);
    }

    Ok(Value::Unit)
}

// fn body(self) -> Expr
fn function_def_body(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let func_meta = interner.function_meta(&func_id);
    if let FunctionBody::Unresolved(_, block_expr, _) = &func_meta.function_body {
        Ok(Value::expression(ExpressionKind::Block(block_expr.clone())))
    } else {
        Err(InterpreterError::FunctionAlreadyResolved { location })
    }
}

// fn has_named_attribute(self, name: Quoted) -> bool
fn function_def_has_named_attribute(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, name) = check_two_arguments(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let func_meta = interner.function_meta(&func_id);

    let name = get_quoted(name)?;
    let name = name.iter().map(|token| token.to_string()).collect::<Vec<_>>().join("");

    let attributes = &func_meta.custom_attributes;
    let attributes = attributes.iter().map(|attribute| &attribute.contents);

    Ok(Value::Bool(has_named_attribute(&name, attributes, location)))
}

// fn is_unconstrained(self) -> bool
fn function_def_is_unconstrained(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let is_unconstrained = interner.function_modifiers(&func_id).is_unconstrained;
    Ok(Value::Bool(is_unconstrained))
}

// fn module(self) -> Module
fn function_def_module(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let module = interner.function_module(func_id);
    Ok(Value::ModuleDefinition(module))
}

// fn name(self) -> Quoted
fn function_def_name(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let name = interner.function_name(&func_id).to_string();
    let tokens = Rc::new(vec![Token::Ident(name)]);
    Ok(Value::Quoted(tokens))
}

// fn parameters(self) -> [(Quoted, Type)]
fn function_def_parameters(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let func_meta = interner.function_meta(&func_id);

    let parameters = func_meta
        .parameters
        .iter()
        .map(|(hir_pattern, typ, _visibility)| {
            let name = Value::Quoted(Rc::new(hir_pattern_to_tokens(interner, hir_pattern)));
            let typ = Value::Type(typ.clone());
            Value::Tuple(vec![name, typ])
        })
        .collect();

    let typ = Type::Slice(Box::new(Type::Tuple(vec![
        Type::Quoted(QuotedType::Quoted),
        Type::Quoted(QuotedType::Type),
    ])));

    Ok(Value::Slice(parameters, typ))
}

// fn return_type(self) -> Type
fn function_def_return_type(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let func_id = get_function_def(self_argument)?;
    let func_meta = interner.function_meta(&func_id);

    Ok(Value::Type(func_meta.return_type().follow_bindings()))
}

// fn set_body(self, body: Expr)
fn function_def_set_body(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, body_argument) = check_two_arguments(arguments, location)?;
    let body_location = body_argument.1;

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let body_argument = get_expr(interpreter.elaborator.interner, body_argument)?;
    let statement_kind = match body_argument {
        ExprValue::Expression(expression_kind) => StatementKind::Expression(Expression {
            kind: expression_kind,
            span: body_location.span,
        }),
        ExprValue::Statement(statement_kind) => statement_kind,
        ExprValue::LValue(lvalue) => StatementKind::Expression(lvalue.as_expression()),
        ExprValue::Pattern(pattern) => {
            if let Some(expression) = pattern.try_as_expression(interpreter.elaborator.interner) {
                StatementKind::Expression(expression)
            } else {
                let expression =
                    Value::pattern(pattern).display(interpreter.elaborator.interner).to_string();
                let location = body_location;
                return Err(InterpreterError::CannotSetFunctionBody { location, expression });
            }
        }
    };

    let statement = Statement { kind: statement_kind, span: body_location.span };
    let body = BlockExpression { statements: vec![statement] };

    let func_meta = interpreter.elaborator.interner.function_meta_mut(&func_id);
    func_meta.has_body = true;
    func_meta.function_body = FunctionBody::Unresolved(FunctionKind::Normal, body, location.span);

    Ok(Value::Unit)
}

// fn set_parameters(self, parameters: [(Quoted, Type)])
fn function_def_set_parameters(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, parameters_argument) = check_two_arguments(arguments, location)?;
    let parameters_argument_location = parameters_argument.1;

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let (input_parameters, _type) =
        get_slice(interpreter.elaborator.interner, parameters_argument)?;

    // What follows is very similar to what happens in Elaborator::define_function_meta
    let mut parameters = Vec::new();
    let mut parameter_types = Vec::new();
    let mut parameter_idents = Vec::new();

    for input_parameter in input_parameters {
        let mut tuple = get_tuple(
            interpreter.elaborator.interner,
            (input_parameter, parameters_argument_location),
        )?;
        let parameter_type = get_type((tuple.pop().unwrap(), parameters_argument_location))?;
        let parameter_pattern = parse(
            (tuple.pop().unwrap(), parameters_argument_location),
            parser::pattern(),
            "a pattern",
        )?;

        let hir_pattern = interpreter.elaborate_in_function(Some(func_id), |elaborator| {
            elaborator.elaborate_pattern_and_store_ids(
                parameter_pattern,
                parameter_type.clone(),
                DefinitionKind::Local(None),
                &mut parameter_idents,
                None,
            )
        });

        parameters.push((hir_pattern, parameter_type.clone(), Visibility::Private));
        parameter_types.push(parameter_type);
    }

    mutate_func_meta_type(interpreter.elaborator.interner, func_id, |func_meta| {
        func_meta.parameters = parameters.into();
        func_meta.parameter_idents = parameter_idents;
        replace_func_meta_parameters(&mut func_meta.typ, parameter_types);
    });

    Ok(Value::Unit)
}

// fn set_return_type(self, return_type: Type)
fn function_def_set_return_type(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, return_type_argument) = check_two_arguments(arguments, location)?;
    let return_type = get_type(return_type_argument)?;

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let quoted_type_id = interpreter.elaborator.interner.push_quoted_type(return_type.clone());

    mutate_func_meta_type(interpreter.elaborator.interner, func_id, |func_meta| {
        func_meta.return_type = FunctionReturnType::Ty(UnresolvedType {
            typ: UnresolvedTypeData::Resolved(quoted_type_id),
            span: location.span,
        });
        replace_func_meta_return_type(&mut func_meta.typ, return_type);
    });

    Ok(Value::Unit)
}

// fn set_return_public(self, public: bool)
fn function_def_set_return_public(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, public) = check_two_arguments(arguments, location)?;

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let public = get_bool(public)?;

    let func_meta = interpreter.elaborator.interner.function_meta_mut(&func_id);
    func_meta.return_visibility = if public { Visibility::Public } else { Visibility::Private };

    Ok(Value::Unit)
}

// fn set_unconstrained(self, value: bool)
fn function_def_set_unconstrained(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, unconstrained) = check_two_arguments(arguments, location)?;

    let func_id = get_function_def(self_argument)?;
    check_function_not_yet_resolved(interpreter, func_id, location)?;

    let unconstrained = get_bool(unconstrained)?;

    let modifiers = interpreter.elaborator.interner.function_modifiers_mut(&func_id);
    modifiers.is_unconstrained = unconstrained;

    Ok(Value::Unit)
}

// fn add_item(self, item: Quoted)
fn module_add_item(
    interpreter: &mut Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, item) = check_two_arguments(arguments, location)?;
    let module_id = get_module(self_argument)?;
    let module_data = interpreter.elaborator.get_module(module_id);

    let parser = parser::top_level_items();
    let top_level_statements = parse(item, parser, "a top-level item")?;

    interpreter.elaborate_in_module(module_id, module_data.location.file, |elaborator| {
        let mut generated_items = CollectedItems::default();

        for top_level_statement in top_level_statements {
            elaborator.add_item(top_level_statement, &mut generated_items, location);
        }

        if !generated_items.is_empty() {
            elaborator.elaborate_items(generated_items);
        }
    });

    Ok(Value::Unit)
}

// fn functions(self) -> [FunctionDefinition]
fn module_functions(
    interpreter: &Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let module_id = get_module(self_argument)?;
    let module_data = interpreter.elaborator.get_module(module_id);
    let func_ids = module_data
        .value_definitions()
        .filter_map(|module_def_id| {
            if let ModuleDefId::FunctionId(func_id) = module_def_id {
                Some(Value::FunctionDefinition(func_id))
            } else {
                None
            }
        })
        .collect();

    let slice_type = Type::Slice(Box::new(Type::Quoted(QuotedType::FunctionDefinition)));
    Ok(Value::Slice(func_ids, slice_type))
}

// fn has_named_attribute(self, name: Quoted) -> bool
fn module_has_named_attribute(
    interpreter: &Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let (self_argument, name) = check_two_arguments(arguments, location)?;
    let module_id = get_module(self_argument)?;
    let module_data = interpreter.elaborator.get_module(module_id);

    let name = get_quoted(name)?;
    let name = name.iter().map(|token| token.to_string()).collect::<Vec<_>>().join("");

    let attributes = module_data.outer_attributes.iter().chain(&module_data.inner_attributes);

    Ok(Value::Bool(has_named_attribute(&name, attributes, location)))
}

// fn is_contract(self) -> bool
fn module_is_contract(
    interpreter: &Interpreter,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let module_id = get_module(self_argument)?;
    Ok(Value::Bool(interpreter.elaborator.module_is_contract(module_id)))
}

// fn name(self) -> Quoted
fn module_name(
    interner: &NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let self_argument = check_one_argument(arguments, location)?;
    let module_id = get_module(self_argument)?;
    let name = &interner.module_attributes(&module_id).name;
    let tokens = Rc::new(vec![Token::Ident(name.clone())]);
    Ok(Value::Quoted(tokens))
}

fn modulus_be_bits(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    check_argument_count(0, &arguments, location)?;

    let bits = FieldElement::modulus().to_radix_be(2);
    let bits_vector = bits.into_iter().map(|bit| Value::U1(bit != 0)).collect();

    let int_type = Type::Integer(crate::ast::Signedness::Unsigned, IntegerBitSize::One);
    let typ = Type::Slice(Box::new(int_type));
    Ok(Value::Slice(bits_vector, typ))
}

fn modulus_be_bytes(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    check_argument_count(0, &arguments, location)?;

    let bytes = FieldElement::modulus().to_bytes_be();
    let bytes_vector = bytes.into_iter().map(Value::U8).collect();

    let int_type = Type::Integer(crate::ast::Signedness::Unsigned, IntegerBitSize::Eight);
    let typ = Type::Slice(Box::new(int_type));
    Ok(Value::Slice(bytes_vector, typ))
}

fn modulus_le_bits(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let Value::Slice(bits, typ) = modulus_be_bits(interner, arguments, location)? else {
        unreachable!("modulus_be_bits must return slice")
    };
    let reversed_bits = bits.into_iter().rev().collect();
    Ok(Value::Slice(reversed_bits, typ))
}

fn modulus_le_bytes(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    let Value::Slice(bytes, typ) = modulus_be_bytes(interner, arguments, location)? else {
        unreachable!("modulus_be_bytes must return slice")
    };
    let reversed_bytes = bytes.into_iter().rev().collect();
    Ok(Value::Slice(reversed_bytes, typ))
}

fn modulus_num_bits(
    _interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> IResult<Value> {
    check_argument_count(0, &arguments, location)?;
    let bits = FieldElement::max_num_bits().into();
    Ok(Value::U64(bits))
}

// fn quoted_eq(_first: Quoted, _second: Quoted) -> bool
fn quoted_eq(arguments: Vec<(Value, Location)>, location: Location) -> IResult<Value> {
    let (self_value, other_value) = check_two_arguments(arguments, location)?;

    let self_quoted = get_quoted(self_value)?;
    let other_quoted = get_quoted(other_value)?;

    Ok(Value::Bool(self_quoted == other_quoted))
}

fn trait_def_as_trait_constraint(
    interner: &mut NodeInterner,
    arguments: Vec<(Value, Location)>,
    location: Location,
) -> Result<Value, InterpreterError> {
    let argument = check_one_argument(arguments, location)?;

    let trait_id = get_trait_def(argument)?;
    let constraint = interner.get_trait(trait_id).as_constraint(location.span);

    Ok(Value::TraitConstraint(trait_id, constraint.trait_generics))
}

/// Creates a value that holds an `Option`.
/// `option_type` must be a Type referencing the `Option` type.
pub(crate) fn option(option_type: Type, value: Option<Value>) -> IResult<Value> {
    let t = extract_option_generic_type(option_type.clone());

    let (is_some, value) = match value {
        Some(value) => (Value::Bool(true), value),
        None => (Value::Bool(false), zeroed(t)?),
    };

    let mut fields = HashMap::default();
    fields.insert(Rc::new("_is_some".to_string()), is_some);
    fields.insert(Rc::new("_value".to_string()), value);
    Ok(Value::Struct(fields, option_type))
}

/// Given a type, assert that it's an Option<T> and return the Type for T
pub(crate) fn extract_option_generic_type(typ: Type) -> Type {
    let Type::Struct(struct_type, mut generics) = typ else {
        panic!("Expected type to be a struct");
    };

    let struct_type = struct_type.borrow();
    assert_eq!(struct_type.name.0.contents, "Option");

    generics.pop().expect("Expected Option to have a T generic type")
}