Function visit_array

libs/@local/hashql/syntax-jexpr/src/parser/array/visit.rs:36–119

(
    state: &mut ParserState<'arena, 'source, 'spans>,
    token: Token<'source>,
    mut on_item: impl FnMut(
        &mut ParserState<'arena, 'source, 'spans>,
    ) -> Result<(), Diagnostic<C, Spa

              specific token. Not that we hold it temporary, but instead that we consume it."
)]
pub(crate) fn visit_array<'arena, 'source, 'spans, C>(
    state: &mut ParserState<'arena, 'source, 'spans>,
    token: Token<'source>,
    mut on_item: impl FnMut(
        &mut ParserState<'arena, 'source, 'spans>,
    ) -> Result<(), Diagnostic<C, SpanId, Critical>>,
) -> Result<TextRange, Diagnostic<C, SpanId, Critical>>
where
    C: From<ArrayDiagnosticCategory>,
{
    debug_assert_eq!(token.kind.syntax(), SyntaxKind::LBracket);

    let mut span = token.span;
    let mut index: usize = 0;

    loop {
        let next = state
            .peek_expect(SyntaxKindSet::COMPLETE)
            .change_category(ArrayDiagnosticCategory::Lexer)
            .change_category(C::from)?;

        let (next_kind, next_span) = (next.kind.syntax(), next.span);

        if next_kind == SyntaxKind::RBracket {
            state
                .advance(SyntaxKindSet::COMPLETE)
                .change_category(ArrayDiagnosticCategory::Lexer)
                .change_category(C::from)?;

            span = span.cover(next_span);
            break;
        }

        if index == 0 {
            verify_no_repeat(
                state,
                SyntaxKindSet::from_slice(&[SyntaxKind::Comma]),
                SyntaxKindSet::EMPTY,
                |_, spans, _| leading_commas(&spans),
            )
            .change_category(C::from)?;
        } else {
            // we need to check if the next token is a comma
            // in case it isn't we error out
            if next_kind == SyntaxKind::Comma {
                // advance the cursor to the next token and continue as it nothing has happened
                state
                    .advance(SyntaxKindSet::COMPLETE)
                    .change_category(ArrayDiagnosticCategory::Lexer)
                    .change_category(C::from)?;

                verify_no_repeat(
                    state,
                    SyntaxKindSet::from_slice(&[SyntaxKind::Comma]),
                    SyntaxKindSet::from_slice(&[SyntaxKind::RBracket]),
                    |state, mut spans, verify| match verify {
                        VerifyState::Trailing => {
                            // if trailing comma is found, then the first comma is also affected