pub fn parse_abstract(

    ctx: &mut ParseContext,

    node: &Node,

) -> Result<Option<AbstractLiteral<Expression>>, FatalParseError> {

    if typecheck_abstract_literal(ctx, node) {

        return Ok(None);

    }

    match node.kind() {

        "record" => parse_record(ctx, node),

        "tuple" => parse_tuple(ctx, node),

        "matrix" => parse_matrix(ctx, node),

        "set_literal" => parse_set_literal(ctx, node),

}

fn typecheck_abstract_literal(ctx: &mut ParseContext, node: &Node) -> bool {

    let expected = match ctx.typechecking_context {

        TypecheckingContext::Boolean => "bool",

        TypecheckingContext::Set => "set",

        TypecheckingContext::SetOrMatrix => "set or matrix",

        TypecheckingContext::Matrix => "matrix",

        TypecheckingContext::Tuple => "tuple",

        TypecheckingContext::Record => "record",

        TypecheckingContext::Unknown => "unknown",

    let got = match node.kind() {

        "set_literal" => "set",

        "matrix" => "matrix",

        "tuple" => "tuple",

        "record" => "record",

    if expected != "unknown"

        && !(ctx.typechecking_context == TypecheckingContext::SetOrMatrix

            && matches!(got, "set" | "matrix"))

        && expected != got

        ctx.record_error(RecoverableParseError::new(

            format!(

                ctx.source_code[node.start_byte()..node.end_byte()].trim(),

            Some(node.range()),

        return true;

    }

    false

}

fn parse_record(

    ctx: &mut ParseContext,

    node: &Node,

) -> Result<Option<AbstractLiteral<Expression>>, FatalParseError> {

    let mut values = Vec::new();

    let mut had_error = false;

    for child in node.children_by_field_name("name_value_pair", &mut node.walk()) {

        let Some(name_node) = field!(recover, ctx, child, "name") else {

        let name_str = &ctx.source_code[name_node.start_byte()..name_node.end_byte()];

        let name = conjure_cp_core::ast::Name::user(name_str);

        let Some(value_node) = field!(recover, ctx, child, "value") else {

        let saved_ctx = ctx.typechecking_context;

        ctx.typechecking_context = ctx.inner_typechecking_context;

        ctx.inner_typechecking_context = TypecheckingContext::Unknown;

        let Some(value) = parse_expression(ctx, value_node)? else {

        ctx.inner_typechecking_context = ctx.typechecking_context;

        ctx.typechecking_context = saved_ctx;

        values.push(conjure_cp_core::ast::records::Field { name, value });

    if had_error {

        Ok(Some(AbstractLiteral::Record(values)))

}

fn parse_tuple(

    ctx: &mut ParseContext,

    node: &Node,

) -> Result<Option<AbstractLiteral<Expression>>, FatalParseError> {

    let saved_ctx = ctx.typechecking_context;

    let saved_inner_ctx = ctx.inner_typechecking_context;

    let mut elements = Vec::new();

    let mut had_error = false;

    for child in named_children(node) {

        ctx.typechecking_context = saved_inner_ctx;

        ctx.inner_typechecking_context = TypecheckingContext::Unknown;

        let Some(expr) = parse_expression(ctx, child)? else {

        elements.push(expr);

    ctx.typechecking_context = saved_ctx;

    ctx.inner_typechecking_context = saved_inner_ctx;

    if had_error {

        Ok(Some(AbstractLiteral::Tuple(elements)))

}

fn parse_matrix(

    ctx: &mut ParseContext,

    node: &Node,

) -> Result<Option<AbstractLiteral<Expression>>, FatalParseError> {

    let saved_ctx = ctx.typechecking_context;

    let saved_inner_ctx = ctx.inner_typechecking_context;

    let mut elements = vec![];

    let mut domain: Option<DomainPtr> = None;

    let mut had_error = false;

    for child in named_children(node) {

        if child.kind() == "arithmetic_expr"

            || child.kind() == "bool_expr"

            || child.kind() == "comparison_expr"

            || child.kind() == "atom"

            ctx.typechecking_context = saved_inner_ctx;

            ctx.inner_typechecking_context = TypecheckingContext::Unknown;

            let Some(expr) = parse_expression(ctx, child)? else {

                had_error = true;

                continue;

            elements.push(expr);

            ctx.typechecking_context = TypecheckingContext::Unknown;

            let Some(parsed_domain) = parse_domain(ctx, child)? else {

                had_error = true;

                continue;

            domain = Some(parsed_domain);

    if domain.is_none() {

        let count = elements.len() as i32;

        domain = Some(domain_int!(1..count));

    }

    ctx.typechecking_context = saved_ctx;

    ctx.inner_typechecking_context = saved_inner_ctx;

    if had_error {

        Ok(None)

        Ok(Some(AbstractLiteral::Matrix(elements, domain.unwrap())))

}

fn parse_set_literal(

    ctx: &mut ParseContext,

    node: &Node,

) -> Result<Option<AbstractLiteral<Expression>>, FatalParseError> {

    let saved_ctx = ctx.typechecking_context;

    let saved_inner_ctx = ctx.inner_typechecking_context;

    let mut elements = Vec::new();

    let mut had_error = false;

    for child in named_children(node) {

        ctx.typechecking_context = saved_inner_ctx;

        ctx.inner_typechecking_context = TypecheckingContext::Unknown;

        let Some(expr) = parse_expression(ctx, child)? else {

            had_error = true;

            continue;

        elements.push(expr);

    ctx.typechecking_context = saved_ctx;

    ctx.inner_typechecking_context = saved_inner_ctx;

    if had_error {

        Ok(None)

        Ok(Some(AbstractLiteral::Set(elements)))

}