pub fn parse_atom(

    ctx: &mut ParseContext,

    node: &Node,

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

    match node.kind() {

        "atom" | "sub_atom_expr" => parse_atom(ctx, &named_child!(node)),

        "metavar" => {

            let ident = field!(node, "identifier");

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

            Ok(Some(Expression::Metavar(

                Metadata::new(),

                Ustr::from(name_str),

            )))

        "identifier" => {

            let Some(var) = parse_variable(ctx, node)? else {

                return Ok(None);

            Ok(Some(Expression::Atomic(Metadata::new(), var)))

        "from_solution" => {

        "constant" => {

            let Some(lit) = parse_constant(ctx, node)? else {

                return Ok(None);

            Ok(Some(Expression::Atomic(

                Metadata::new(),

                Atom::Literal(lit),

            )))

        "matrix" | "record" | "tuple" | "set_literal" => {

            let Some(abs) = parse_abstract(ctx, node)? else {

                return Ok(None);

            Ok(Some(Expression::AbstractLiteral(Metadata::new(), abs)))

        "flatten" => parse_flatten(ctx, node),

        "index_or_slice" => parse_index_or_slice(ctx, node),

        "set_operation" => parse_binary_expression(ctx, node),

}

fn parse_index_or_slice(

    ctx: &mut ParseContext,

    node: &Node,

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

    let saved_context = ctx.typechecking_context;

    ctx.typechecking_context = TypecheckingContext::Unknown;

    let Some(collection) = parse_atom(ctx, &field!(node, "collection"))? else {

    ctx.typechecking_context = saved_context;

    let mut indices = Vec::new();

    for idx_node in named_children(&field!(node, "indices")) {

        indices.push(parse_index(ctx, &idx_node)?);

    let has_null_idx = indices.iter().any(|idx| idx.is_none());

    if has_null_idx {

        Ok(Some(Expression::UnsafeSlice(

            Metadata::new(),

            Moo::new(collection),

            indices,

        )))

        let idx_exprs: Vec<Expression> = indices.into_iter().map(|idx| idx.unwrap()).collect();

        Ok(Some(Expression::UnsafeIndex(

            Metadata::new(),

            Moo::new(collection),

            idx_exprs,

        )))

}

fn parse_index(ctx: &mut ParseContext, node: &Node) -> Result<Option<Expression>, FatalParseError> {

    match node.kind() {

        "arithmetic_expr" | "atom" => {

            ctx.typechecking_context = TypecheckingContext::Arithmetic;

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

                return Ok(None);

            Ok(Some(expr))

        "null_index" => Ok(None),

}

fn parse_variable(ctx: &mut ParseContext, node: &Node) -> Result<Option<Atom>, FatalParseError> {

    let raw_name = &ctx.source_code[node.start_byte()..node.end_byte()];

    let name = Name::user(raw_name.trim());

    if let Some(symbols) = &ctx.symbols {

        let lookup_result = {

            let symbols_read = symbols.read();

            symbols_read.lookup(&name)

        if let Some(decl) = lookup_result {

            let hover = HoverInfo {

                description: format!("Variable: {name}"),

                kind: Some(SymbolKind::Decimal),

                ty: decl.domain().map(|d| d.to_string()),

                decl_span: None,

            span_with_hover(node, ctx.source_code, ctx.source_map, hover);

            if let Some(error_msg) = typecheck_variable(&decl, ctx.typechecking_context) {

                ctx.record_error(RecoverableParseError::new(error_msg, Some(node.range())));

                return Ok(None);

            }

            Ok(Some(Atom::Reference(conjure_cp_core::ast::Reference::new(

                decl,

            ))))

            ctx.record_error(RecoverableParseError::new(

                format!("The identifier '{}' is not defined", raw_name),

                Some(node.range()),

            Ok(None)

}

fn typecheck_variable(decl: &DeclarationPtr, context: TypecheckingContext) -> Option<String> {

    if context == TypecheckingContext::Unknown {

        return None;

    }

    let domain = decl.domain()?;

    let ground_domain = domain.resolve()?;

    let expected = match context {

        TypecheckingContext::Boolean => "bool",

        TypecheckingContext::Arithmetic => "int",

    let actual = match ground_domain.as_ref() {

        GroundDomain::Bool => "bool",

        GroundDomain::Int(_) => "int",

        GroundDomain::Matrix(_, _) => "matrix",

    if expected == actual {

        return None;

    }

    Some(format!(

        "Type error:\n\tExpected: {}\n\tGot: {}",

        expected, actual

    ))

}

fn parse_constant(ctx: &mut ParseContext, node: &Node) -> Result<Option<Literal>, FatalParseError> {

    let inner = named_child!(node);

    let raw_value = &ctx.source_code[inner.start_byte()..inner.end_byte()];

    let lit = match inner.kind() {

        "integer" => {

            let value = parse_int(ctx, &inner)?;

            Literal::Int(value)

        "TRUE" => {

            let hover = HoverInfo {

                description: format!("Boolean constant: {raw_value}"),

                kind: None,

                ty: None,

                decl_span: None,

            };

            span_with_hover(&inner, ctx.source_code, ctx.source_map, hover);

            Literal::Bool(true)

        "FALSE" => {

            let hover = HoverInfo {

                description: format!("Boolean constant: {raw_value}"),

                kind: None,

                ty: None,

                decl_span: None,

            };

            span_with_hover(&inner, ctx.source_code, ctx.source_map, hover);

            Literal::Bool(false)

    if ctx.typechecking_context != TypecheckingContext::Unknown {

        let expected = match ctx.typechecking_context {

            TypecheckingContext::Boolean => "bool",

            TypecheckingContext::Arithmetic => "int",

        let actual = match &lit {

            Literal::Bool(_) => "bool",

            Literal::Int(_) => "int",

        if expected != actual {

            ctx.record_error(RecoverableParseError::new(

                format!("Type error:\n\tExpected: {}\n\tGot: {}", expected, actual),

                Some(node.range()),

            return Ok(None);

        }

    }

    Ok(Some(lit))

}

pub(crate) fn parse_int(ctx: &ParseContext, node: &Node) -> Result<i32, FatalParseError> {

    let raw_value = &ctx.source_code[node.start_byte()..node.end_byte()];

    raw_value.parse::<i32>().map_err(|_e| {

}