Function parse_array

libs/@local/hashql/syntax-jexpr/src/parser/array/mod.rs:188–243

(
    state: &mut ParserState<'heap, 'source, '_>,
    token: Token<'source>,
)

}

pub(crate) fn parse_array<'heap, 'source>(
    state: &mut ParserState<'heap, 'source, '_>,
    token: Token<'source>,
) -> Result<Expr<'heap>, ParserDiagnostic> {
    debug_assert_eq!(token.kind.syntax(), SyntaxKind::LBracket);

    let mut function = None;
    let mut arguments = Vec::new();
    let mut labeled_arguments = Vec::new();

    let span = visit_array(state, token, |state| {
        match &mut function {
            Some(_) => {
                if let Some(labeled) = parse_labelled_argument(state)? {
                    labeled_arguments.extend(labeled);
                    return Ok(());
                }

                let expr = parse_expr(state)?;

                arguments.push(Argument {
                    id: NodeId::PLACEHOLDER,
                    span: expr.span,
                    value: Box::new_in(expr, state.heap()),
                });
            }
            function @ None => *function = Some(parse_expr(state)?),
        }

        Ok(())
    })
    .change_category(From::from)?;

    let span = state.insert_span(Span {
        range: span,
        pointer: Some(state.current_pointer()),
    });

    let Some(function) = function else {
        return Err(empty(span).map_category(From::from));
    };

    let heap = state.heap();

    Ok(Expr {
        id: NodeId::PLACEHOLDER,
        span,
        kind: ExprKind::Call(CallExpr {
            id: NodeId::PLACEHOLDER,
            span,
            function: Box::new_in(function, heap),
            arguments: arguments.into_iter().collect_in(heap),
            labeled_arguments: labeled_arguments.into_iter().collect_in(heap),
        }),
    })
}

#[cfg(test)]