arity_parser/parser/

expr.rs

use crate::parser::context::{
    ParserCtx, StatementTracker, push_token_diagnostic_ctx as push_token_diagnostic,
};
use crate::parser::diagnostics::ParseDiagnostic;
use crate::parser::events::{Event, ExprParse};
use crate::parser::lexer::{TokKind, Token};
use crate::parser::recovery::error_expr_to_line_end;
use crate::parser::structural::{
    parse_for_expr, parse_function_expr, parse_if_expr, parse_repeat_expr, parse_while_expr,
};
use crate::syntax::SyntaxKind;

fn is_assignment_operator(kind: &TokKind) -> bool {
    matches!(
        kind,
        TokKind::AssignLeft
            | TokKind::SuperAssign
            | TokKind::AssignRight
            | TokKind::SuperAssignRight
            | TokKind::AssignEq
            | TokKind::Walrus
    )
}

fn is_infix_operator(kind: &TokKind) -> bool {
    infix_binding_power(kind).is_some()
}

fn next_operator<'a>(
    ctx: &ParserCtx<'a>,
    start: usize,
    inside_brackets: bool,
) -> Option<(usize, &'a Token<'a>)> {
    let op_idx = ctx.skip_ws(start);
    let op = ctx.token(op_idx)?;
    if matches!(op.kind, TokKind::Newline | TokKind::Comment) {
        if !inside_brackets {
            return None;
        }
        let next_idx = ctx.skip_ws_newlines_comments(start);
        let next = ctx.token(next_idx)?;
        if is_assignment_operator(&next.kind) || is_infix_operator(&next.kind) {
            return Some((next_idx, next));
        }
        return None;
    }
    if is_assignment_operator(&op.kind) || is_infix_operator(&op.kind) {
        return Some((op_idx, op));
    }
    None
}

pub(crate) fn parse_expr(
    tokens: &[Token],
    start: usize,
    min_bp: u8,
    diagnostics: &mut Vec<ParseDiagnostic>,
    md_default: bool,
) -> Option<ExprParse> {
    parse_expr_with_mode(tokens, start, min_bp, diagnostics, false, false, md_default)
}

pub(crate) fn parse_expr_in_brackets(
    tokens: &[Token],
    start: usize,
    min_bp: u8,
    diagnostics: &mut Vec<ParseDiagnostic>,
    md_default: bool,
) -> Option<ExprParse> {
    parse_expr_with_mode(tokens, start, min_bp, diagnostics, true, true, md_default)
}

fn parse_expr_with_mode(
    tokens: &[Token],
    start: usize,
    min_bp: u8,
    diagnostics: &mut Vec<ParseDiagnostic>,
    allow_newline_prefix: bool,
    inside_brackets: bool,
    md_default: bool,
) -> Option<ExprParse> {
    let ctx = ParserCtx::new(tokens, md_default);
    let start_non_ws = if allow_newline_prefix {
        ctx.skip_ws_and_newlines(start)
    } else {
        ctx.skip_ws(start)
    };
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::IfKw)
    ) {
        return parse_if_expr(tokens, start_non_ws, diagnostics, md_default);
    }
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::ForKw)
    ) {
        return parse_for_expr(tokens, start_non_ws, diagnostics, md_default);
    }
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::WhileKw)
    ) {
        return parse_while_expr(tokens, start_non_ws, diagnostics, md_default);
    }
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::RepeatKw)
    ) {
        return parse_repeat_expr(tokens, start_non_ws, diagnostics, md_default);
    }
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::FunctionKw)
    ) {
        return parse_function_expr(
            tokens,
            start_non_ws,
            inside_brackets,
            diagnostics,
            md_default,
        );
    }
    if matches!(
        tokens.get(start_non_ws).map(|t| &t.kind),
        Some(TokKind::LambdaFn)
    ) {
        return parse_function_expr(
            tokens,
            start_non_ws,
            inside_brackets,
            diagnostics,
            md_default,
        );
    }

    let mut lhs = parse_prefix(
        &ctx,
        start,
        diagnostics,
        allow_newline_prefix,
        inside_brackets,
    )?;

    // A bare comment parses as an atom (so a comment-only argument such as
    // `c(1, # note\n)` has something to hang on), but it can never be the
    // operand of an operator. Do not let the infix loop bind a following
    // operator to it: inside brackets `next_operator` peeks across newlines,
    // so in `c(-1, # a\n -2)` the `-` that starts the next argument would
    // otherwise be misread as a binary minus on the comment.
    if lhs.end == lhs.start + 1 && tokens[lhs.start].kind.is_comment_like() {
        return Some(lhs);
    }

    loop {
        lhs = parse_postfix_chain(&ctx, lhs, inside_brackets, diagnostics);

        let Some((op_idx, op)) = next_operator(&ctx, lhs.end, inside_brackets) else {
            break;
        };

        if is_assignment_operator(&op.kind) {
            let (l_bp, r_bp) = (1, 1);
            if l_bp < min_bp {
                break;
            }

            let rhs_start = op_idx + 1;
            // A pending operator means the line is incomplete, so newlines and
            // comments before the RHS operand are not statement terminators or
            // operands — skip past them to the operand (R does the same). The
            // skipped tokens stay in the tree as trivia between the operator and
            // the operand, emitted by the event builder.
            let rhs_operand = ctx.skip_ws_newlines_comments(rhs_start);
            let Some(rhs) = parse_expr_with_mode(
                tokens,
                rhs_operand,
                r_bp,
                diagnostics,
                true,
                inside_brackets,
                ctx.md_default(),
            ) else {
                push_token_diagnostic(diagnostics, "expected assignment right-hand side", op);
                return Some(error_expr_to_line_end(tokens, lhs.start, rhs_start));
            };

            lhs = build_assignment_expr(lhs, op_idx, rhs);
            continue;
        }

        let Some((l_bp, r_bp)) = infix_binding_power(&op.kind) else {
            break;
        };
        if l_bp < min_bp {
            break;
        }

        let rhs_start = op_idx + 1;
        // A pending operator means the line is incomplete, so newlines and
        // comments before the RHS operand are not statement terminators or
        // operands — skip past them to the operand (the skipped tokens remain
        // in the tree as trivia between the operator and the operand).
        let rhs_operand = ctx.skip_ws_newlines_comments(rhs_start);
        // The extract/namespace operators (`$`, `@`, `::`, `:::`) share the
        // highest precedence tier with the postfix operators (`[`, `[[`, `(`)
        // and are all left-associative, so `a$b[c]` is `(a$b)[c]` and
        // `pkg::fn(x)` is `(pkg::fn)(x)` (R's grammar). Their RHS is a bare
        // member name, not a full expression: parse only the prefix operand so
        // any trailing postfix binds to the *whole* extract expression via the
        // outer loop's `parse_postfix_chain`, rather than being swallowed into
        // the RHS.
        let rhs = if is_extract_operator(&op.kind) {
            parse_prefix(&ctx, rhs_operand, diagnostics, true, inside_brackets)
        } else {
            parse_expr_with_mode(
                tokens,
                rhs_operand,
                r_bp,
                diagnostics,
                true,
                inside_brackets,
                ctx.md_default(),
            )
        };
        let Some(rhs) = rhs else {
            push_token_diagnostic(
                diagnostics,
                "expected right-hand side for binary operator",
                op,
            );
            return Some(error_expr_to_line_end(tokens, lhs.start, rhs_start));
        };

        if op.kind == TokKind::Pipe
            && let Some(callee_idx) = direct_call_callee(&rhs)
            && let Some(callee) = tokens.get(callee_idx)
            && callee.kind == TokKind::Ident
            && ident_denotes_return(callee.text)
        {
            push_token_diagnostic(
                diagnostics,
                "function 'return' not supported in RHS call of a pipe",
                callee,
            );
        }

        if matches!(op.kind, TokKind::Colon2 | TokKind::Colon3)
            && lhs
                .events
                .iter()
                .any(|event| matches!(event, Event::Start(SyntaxKind::CALL_EXPR)))
        {
            push_token_diagnostic(
                diagnostics,
                "namespace operator requires a package name on the left-hand side",
                op,
            );
        }

        if matches!(op.kind, TokKind::Colon2 | TokKind::Colon3)
            && matches!(expr_root_kind(&rhs), Some(SyntaxKind::BLOCK_EXPR))
        {
            push_token_diagnostic(
                diagnostics,
                "namespace operator requires an identifier on the right-hand side",
                op,
            );
        }

        if matches!(op.kind, TokKind::Colon2 | TokKind::Colon3)
            && matches!(
                expr_root_kind(&rhs),
                Some(SyntaxKind::INT | SyntaxKind::FLOAT | SyntaxKind::COMPLEX)
            )
        {
            push_token_diagnostic(
                diagnostics,
                "namespace operator requires an identifier on the right-hand side",
                op,
            );
        }

        if matches!(op.kind, TokKind::Colon2 | TokKind::Colon3)
            && matches!(expr_root_kind(&rhs), Some(SyntaxKind::IDENT))
        {
            let rhs_tok_idx = ctx.skip_ws(rhs.start);
            if let Some(tok) = tokens.get(rhs_tok_idx)
                && ident_is_special_constant(tok.text)
            {
                push_token_diagnostic(
                    diagnostics,
                    "namespace operator requires an identifier on the right-hand side",
                    op,
                );
            }
        }

        if matches!(op.kind, TokKind::Colon2 | TokKind::Colon3)
            && matches!(expr_root_kind(&lhs), Some(SyntaxKind::BINARY_EXPR))
            && lhs
                .events
                .iter()
                .any(|event| matches!(event, Event::Tok(idx) if matches!(tokens[*idx].kind, TokKind::Colon2 | TokKind::Colon3)))
        {
            push_token_diagnostic(diagnostics, "namespace operator chaining is not allowed", op);
        }

        lhs = build_binary_expr(lhs, op_idx, rhs);
    }

    Some(lhs)
}

fn parse_prefix(
    ctx: &ParserCtx<'_>,
    start: usize,
    diagnostics: &mut Vec<ParseDiagnostic>,
    allow_newline_prefix: bool,
    inside_brackets: bool,
) -> Option<ExprParse> {
    let tokens = ctx.tokens();
    let i = if allow_newline_prefix {
        ctx.skip_ws_and_newlines(start)
    } else {
        ctx.skip_ws(start)
    };
    let tok = tokens.get(i)?;

    match tok.kind {
        TokKind::Plus | TokKind::Minus | TokKind::Bang | TokKind::Tilde | TokKind::Question => {
            let rbp = match tok.kind {
                TokKind::Tilde => 41,
                TokKind::Question => 1,
                TokKind::Bang => 70,
                _ => 130,
            };
            let operand_start = i + 1;
            let Some(operand) = parse_expr_with_mode(
                tokens,
                operand_start,
                rbp,
                diagnostics,
                true,
                inside_brackets,
                ctx.md_default(),
            ) else {
                push_token_diagnostic(diagnostics, "expected operand for unary operator", tok);
                return Some(error_expr_to_line_end(tokens, i, operand_start));
            };
            let mut events = Vec::new();
            events.push(Event::Start(SyntaxKind::UNARY_EXPR));
            events.push(Event::Tok(i));
            for idx in (i + 1)..operand.start {
                events.push(Event::Tok(idx));
            }
            events.extend(operand.events);
            events.push(Event::Finish);
            Some(ExprParse {
                start: i,
                end: operand.end,
                events,
            })
        }
        TokKind::Ident
        | TokKind::Int
        | TokKind::Float
        | TokKind::Complex
        | TokKind::String
        | TokKind::Comment
        | TokKind::UserOp => Some(ExprParse {
            start: i,
            end: i + 1,
            events: vec![Event::Tok(i)],
        }),
        TokKind::LParen => {
            let inner_start = i + 1;
            let mut expr_start = inner_start;
            while matches!(
                tokens.get(expr_start).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                expr_start += 1;
            }
            let Some(inner) = parse_expr_with_mode(
                tokens,
                expr_start,
                0,
                diagnostics,
                true,
                true,
                ctx.md_default(),
            ) else {
                push_token_diagnostic(diagnostics, "expected expression after '('", tok);
                return Some(error_expr_to_line_end(tokens, i, inner_start));
            };
            let mut close_idx = inner.end;
            while matches!(
                tokens.get(close_idx).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                close_idx += 1;
            }
            if !matches!(
                tokens.get(close_idx).map(|t| &t.kind),
                Some(TokKind::RParen)
            ) {
                push_token_diagnostic(diagnostics, "expected ')'", tok);
                let mut events = Vec::new();
                events.push(Event::Start(SyntaxKind::PAREN_EXPR));
                events.push(Event::Tok(i));
                for idx in inner_start..inner.start {
                    events.push(Event::Tok(idx));
                }
                events.extend(inner.events);
                for idx in inner.end..close_idx {
                    events.push(Event::Tok(idx));
                }
                events.push(Event::Finish);
                return Some(ExprParse {
                    start: i,
                    end: close_idx,
                    events,
                });
            }

            let mut events = Vec::new();
            events.push(Event::Start(SyntaxKind::PAREN_EXPR));
            events.push(Event::Tok(i));
            for idx in inner_start..inner.start {
                events.push(Event::Tok(idx));
            }
            events.extend(inner.events);
            for idx in inner.end..close_idx {
                events.push(Event::Tok(idx));
            }
            events.push(Event::Tok(close_idx));
            events.push(Event::Finish);

            Some(ExprParse {
                start: i,
                end: close_idx + 1,
                events,
            })
        }
        TokKind::LBrace => parse_block_expr(ctx, i, diagnostics),
        TokKind::Star
        | TokKind::Slash
        | TokKind::Caret
        | TokKind::AssignLeft
        | TokKind::SuperAssign
        | TokKind::AssignRight
        | TokKind::SuperAssignRight
        | TokKind::AssignEq
        | TokKind::Walrus
        | TokKind::Colon
        | TokKind::Or
        | TokKind::Or2
        | TokKind::And
        | TokKind::And2
        | TokKind::Equal2
        | TokKind::NotEqual
        | TokKind::LessThan
        | TokKind::LessThanOrEqual
        | TokKind::GreaterThan
        | TokKind::GreaterThanOrEqual
        | TokKind::Colon2
        | TokKind::Colon3
        | TokKind::Dollar
        | TokKind::At
        | TokKind::Semicolon
        | TokKind::Comma
        | TokKind::Pipe => {
            push_token_diagnostic(diagnostics, "unexpected operator at expression start", tok);
            Some(error_expr_to_line_end(tokens, i, i + 1))
        }
        TokKind::Whitespace
        | TokKind::Newline
        | TokKind::RParen
        | TokKind::RBrack
        | TokKind::RBrack2
        | TokKind::RBrace
        | TokKind::IfKw
        | TokKind::ElseKw
        | TokKind::ForKw
        | TokKind::WhileKw
        | TokKind::RepeatKw
        | TokKind::FunctionKw
        | TokKind::LambdaFn
        | TokKind::InKw
        | TokKind::LBrack
        | TokKind::LBrack2
        | TokKind::RoxygenMarker
        | TokKind::RoxygenAt
        | TokKind::RoxygenTagName
        | TokKind::RoxygenTagArg
        | TokKind::RoxygenText
        | TokKind::RoxygenCode
        | TokKind::RoxygenRdMacro
        | TokKind::RoxygenMdLink
        | TokKind::RoxygenMdBracket
        | TokKind::RoxygenMdImage
        | TokKind::RoxygenMdDelim
        | TokKind::RoxygenMdCode
        | TokKind::RoxygenMdListMarker
        | TokKind::RoxygenMdFence
        | TokKind::RoxygenMdHtml
        | TokKind::RoxygenMdHtmlBlock
        | TokKind::RoxygenMdTableDelim
        | TokKind::RoxygenMdHeading
        | TokKind::RoxygenMdSetextUnderline
        | TokKind::RoxygenMdBlockQuote
        | TokKind::RoxygenMdThematicBreak
        | TokKind::Unknown => None,
    }
}

fn parse_block_expr(
    ctx: &ParserCtx<'_>,
    start: usize,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> Option<ExprParse> {
    let tokens = ctx.tokens();
    let mut i = start + 1;
    let mut events = vec![Event::Start(SyntaxKind::BLOCK_EXPR), Event::Tok(start)];
    let mut statements = StatementTracker::default();

    loop {
        let next = ctx.skip_ws(i);
        let Some(tok) = tokens.get(next) else {
            push_token_diagnostic(diagnostics, "expected '}' to close block", &tokens[start]);
            for idx in i..tokens.len() {
                events.push(Event::Tok(idx));
            }
            events.push(Event::Finish);
            return Some(ExprParse {
                start,
                end: tokens.len(),
                events,
            });
        };

        if tok.kind == TokKind::RBrace {
            for idx in i..next {
                events.push(Event::Tok(idx));
            }
            events.push(Event::Tok(next));
            events.push(Event::Finish);
            return Some(ExprParse {
                start,
                end: next + 1,
                events,
            });
        }

        // Consume newlines and semicolons as statement separators.
        if matches!(tok.kind, TokKind::Newline | TokKind::Semicolon) {
            for idx in i..=next {
                events.push(Event::Tok(idx));
            }
            i = next + 1;
            continue;
        }

        if tok.kind == TokKind::RoxygenMarker {
            // Emit the leading whitespace gap, then the grouped block.
            for idx in i..next {
                events.push(Event::Tok(idx));
            }
            i = crate::parser::roxygen::emit_roxygen_block(
                tokens,
                next,
                &mut events,
                ctx.md_default(),
            );
            continue;
        }

        let before = diagnostics.len();
        if let Some(expr) = parse_expr(tokens, i, 0, diagnostics, ctx.md_default()) {
            // As at the root: a comment is an atom, not a statement.
            if !tokens[expr.start].kind.is_comment_like() {
                let recovered = diagnostics.len() > before;
                statements.record(tokens, expr.start, expr.end, recovered, diagnostics);
            }
            for idx in i..expr.start {
                events.push(Event::Tok(idx));
            }
            events.extend(expr.events);
            i = expr.end;
        } else {
            events.push(Event::Tok(i));
            i += 1;
            statements.record_recovery(i);
        }
    }
}

fn parse_postfix_chain(
    ctx: &ParserCtx<'_>,
    mut lhs: ExprParse,
    inside_brackets: bool,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> ExprParse {
    let tokens = ctx.tokens();
    loop {
        // At top level no newline is allowed between the callee and `(` — `f\n(x)`
        // is two statements in R. Inside brackets the newline is insignificant, so
        // `structure(list\n(h = 1))` is `structure(list(h = 1))` and `f(x\n[i])`
        // is `f(x[i])`; skip across it to find the postfix operator.
        let after_lhs = if inside_brackets {
            ctx.skip_ws_and_newlines(lhs.end)
        } else {
            ctx.skip_ws(lhs.end)
        };
        if matches!(
            tokens.get(after_lhs).map(|t| &t.kind),
            Some(TokKind::LParen)
        ) {
            lhs = parse_call_expr(ctx, lhs, after_lhs, diagnostics);
            continue;
        }
        if matches!(
            tokens.get(after_lhs).map(|t| &t.kind),
            Some(TokKind::LBrack)
        ) {
            lhs = parse_subset_expr(ctx, lhs, after_lhs, diagnostics);
            continue;
        }
        if matches!(
            tokens.get(after_lhs).map(|t| &t.kind),
            Some(TokKind::LBrack2)
        ) {
            lhs = parse_subset2_expr(ctx, lhs, after_lhs, diagnostics);
            continue;
        }
        break;
    }
    lhs
}

fn build_binary_like_expr(
    kind: SyntaxKind,
    lhs: ExprParse,
    op_idx: usize,
    rhs: ExprParse,
) -> ExprParse {
    let mut events = Vec::new();
    events.push(Event::Start(kind));
    events.extend(lhs.events);
    for idx in lhs.end..op_idx {
        events.push(Event::Tok(idx));
    }
    events.push(Event::Tok(op_idx));
    for idx in (op_idx + 1)..rhs.start {
        events.push(Event::Tok(idx));
    }
    events.extend(rhs.events);
    events.push(Event::Finish);

    ExprParse {
        start: lhs.start,
        end: rhs.end,
        events,
    }
}

fn build_binary_expr(lhs: ExprParse, op_idx: usize, rhs: ExprParse) -> ExprParse {
    build_binary_like_expr(SyntaxKind::BINARY_EXPR, lhs, op_idx, rhs)
}

fn build_assignment_expr(lhs: ExprParse, op_idx: usize, rhs: ExprParse) -> ExprParse {
    build_binary_like_expr(SyntaxKind::ASSIGNMENT_EXPR, lhs, op_idx, rhs)
}

/// Returns true if tokens starting at `i` match the pattern `name =` (named
/// argument), where `=` is not `==`. The name may be an identifier or a string
/// literal: inside an argument list `=` is always named-argument syntax (never
/// assignment), and R accepts a string as the name (`c("SE" = 13)`).
fn is_named_arg(ctx: &ParserCtx<'_>, i: usize) -> bool {
    let tokens = ctx.tokens();
    if !matches!(
        tokens.get(i).map(|t| &t.kind),
        Some(TokKind::Ident | TokKind::String)
    ) {
        return false;
    }
    let mut next = i + 1;
    while matches!(
        tokens.get(next).map(|t| &t.kind),
        Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
    ) {
        next += 1;
    }
    matches!(tokens.get(next).map(|t| &t.kind), Some(TokKind::AssignEq))
}

fn has_newline(tokens: &[Token], start: usize, end: usize) -> bool {
    tokens[start..end]
        .iter()
        .any(|t| t.kind == TokKind::Newline)
}

fn expr_root_kind(expr: &ExprParse) -> Option<SyntaxKind> {
    expr.events.iter().find_map(|event| match event {
        Event::Start(kind) => Some(*kind),
        _ => None,
    })
}

/// The token index of a call's direct, atomic callee.
///
/// A simple `return()` call starts with `CALL_EXPR, Tok(return)`. Compound
/// callees start with another node (`base::return()`, `(return)()`), and R's
/// native-pipe restriction deliberately does not apply to those forms.
fn direct_call_callee(expr: &ExprParse) -> Option<usize> {
    let mut events = expr.events.iter();
    if !matches!(events.next(), Some(Event::Start(SyntaxKind::CALL_EXPR))) {
        return None;
    }
    match events.next()? {
        Event::Tok(idx) => Some(*idx),
        Event::Start(_) | Event::Leaf(_, _) | Event::Finish => None,
    }
}

/// Whether an identifier denotes R's syntactically special `return` symbol.
///
/// R decodes hexadecimal and octal escapes inside backticked names before it
/// checks native-pipe call heads. Decode only those escapes here; the other R
/// escapes cannot produce a byte in `return`.
fn ident_denotes_return(text: &str) -> bool {
    if text == "return" {
        return true;
    }
    let Some(body) = text
        .strip_prefix('`')
        .and_then(|body| body.strip_suffix('`'))
    else {
        return false;
    };

    let expected = b"return";
    let bytes = body.as_bytes();
    let mut input = 0;
    let mut output = 0;
    while input < bytes.len() {
        let decoded = if bytes[input] != b'\\' {
            let byte = bytes[input];
            input += 1;
            byte
        } else {
            input += 1;
            let Some(&escape) = bytes.get(input) else {
                return false;
            };
            if escape == b'x' {
                input += 1;
                let Some((byte, end)) = decode_ascii_escape(bytes, input, 16, 2) else {
                    return false;
                };
                input = end;
                byte
            } else if matches!(escape, b'0'..=b'7') {
                let Some((byte, end)) = decode_ascii_escape(bytes, input, 8, 3) else {
                    return false;
                };
                input = end;
                byte
            } else {
                return false;
            }
        };

        if expected.get(output) != Some(&decoded) {
            return false;
        }
        output += 1;
    }
    output == expected.len()
}

fn decode_ascii_escape(
    bytes: &[u8],
    start: usize,
    radix: u32,
    max_digits: usize,
) -> Option<(u8, usize)> {
    let mut value = 0_u8;
    let mut end = start;
    while end < bytes.len() && end - start < max_digits {
        let Some(digit) = (bytes[end] as char).to_digit(radix) else {
            break;
        };
        value = value.checked_mul(radix as u8)?.checked_add(digit as u8)?;
        end += 1;
    }
    (end > start).then_some((value, end))
}

pub fn ident_is_special_constant(text: &str) -> bool {
    matches!(
        text,
        "NA" | "NULL"
            | "TRUE"
            | "FALSE"
            | "Inf"
            | "NaN"
            | "NA_integer_"
            | "NA_real_"
            | "NA_complex_"
            | "NA_character_"
    )
}

fn parse_call_expr(
    ctx: &ParserCtx<'_>,
    callee: ExprParse,
    lparen_idx: usize,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> ExprParse {
    let tokens = ctx.tokens();
    let mut events = vec![Event::Start(SyntaxKind::CALL_EXPR)];
    events.extend(callee.events);
    // Whitespace between callee end and `(`
    for idx in callee.end..lparen_idx {
        events.push(Event::Tok(idx));
    }
    events.push(Event::Tok(lparen_idx)); // (

    events.push(Event::Start(SyntaxKind::ARG_LIST));
    let mut i = lparen_idx + 1;

    let mut expect_delimiter = false;
    let mut last_arg_was_comment_only = false;
    loop {
        // Skip whitespace and newlines within the argument list.
        let next_i = ctx.skip_ws_and_newlines(i);
        let had_newline_gap = has_newline(tokens, i, next_i);
        for idx in i..next_i {
            events.push(Event::Tok(idx));
        }
        i = next_i;

        // End of argument list.
        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::RParen) | None) {
            break;
        }

        if expect_delimiter
            && !had_newline_gap
            && let Some(tok) = tokens.get(i)
        {
            let current_is_comment = tok.kind == TokKind::Comment;
            if !current_is_comment && !last_arg_was_comment_only {
                push_token_diagnostic(diagnostics, "expected ',' between arguments", tok);
            }
        }

        // Empty argument (leading or consecutive comma).
        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::Comma)) {
            events.push(Event::Start(SyntaxKind::ARG));
            events.push(Event::Finish);
            events.push(Event::Tok(i)); // ,
            i += 1;
            expect_delimiter = false;
            last_arg_was_comment_only = false;
            continue;
        }

        events.push(Event::Start(SyntaxKind::ARG));
        last_arg_was_comment_only = false;

        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::RoxygenMarker)) {
            // A `#'` line inside an argument list is a comment, not
            // documentation, but the lexer classifies it as roxygen regardless
            // of context. Group the whole roxygen block into this ARG (as the
            // block/root parsers do) so its sub-tokens are one comment-only
            // argument rather than a cascade of stray operands.
            i = crate::parser::roxygen::emit_roxygen_block(
                tokens,
                i,
                &mut events,
                ctx.md_default(),
            );
            last_arg_was_comment_only = true;
        } else if is_named_arg(ctx, i) {
            // Named argument: ident = expr
            events.push(Event::Tok(i)); // ident
            let mut eq_idx = i + 1;
            while matches!(
                tokens.get(eq_idx).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                eq_idx += 1;
            }
            for idx in (i + 1)..eq_idx {
                events.push(Event::Tok(idx));
            }
            if !matches!(tokens.get(eq_idx).map(|t| &t.kind), Some(TokKind::AssignEq)) {
                events.push(Event::Finish); // ARG
                expect_delimiter = true;
                i = eq_idx;
                continue;
            }
            events.push(Event::Tok(eq_idx)); // =
            let val_start = eq_idx + 1;
            let mut value_idx = val_start;
            while matches!(
                tokens.get(value_idx).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                value_idx += 1;
            }
            if matches!(
                tokens.get(value_idx).map(|t| &t.kind),
                Some(TokKind::Comma | TokKind::RParen) | None
            ) {
                for idx in val_start..value_idx {
                    events.push(Event::Tok(idx));
                }
                i = value_idx;
            } else if let Some(val) =
                parse_expr_in_brackets(tokens, value_idx, 0, diagnostics, ctx.md_default())
            {
                for idx in val_start..val.start {
                    events.push(Event::Tok(idx));
                }
                events.extend(val.events);
                i = val.end;
            } else {
                i = val_start;
            }
        } else {
            // Positional argument.
            if let Some(arg) = parse_expr_in_brackets(tokens, i, 0, diagnostics, ctx.md_default()) {
                last_arg_was_comment_only = arg.end == arg.start + 1
                    && matches!(
                        tokens.get(arg.start).map(|t| &t.kind),
                        Some(TokKind::Comment)
                    );
                for idx in i..arg.start {
                    events.push(Event::Tok(idx));
                }
                events.extend(arg.events);
                i = arg.end;
            } else {
                last_arg_was_comment_only = false;
                events.push(Event::Tok(i));
                i += 1;
            }
        }

        events.push(Event::Finish); // ARG
        expect_delimiter = true;

        // Skip whitespace/newlines after arg, then consume optional comma.
        let next_i = ctx.skip_ws_and_newlines(i);
        for idx in i..next_i {
            events.push(Event::Tok(idx));
        }
        i = next_i;

        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::Comma)) {
            events.push(Event::Tok(i)); // ,
            i += 1;
            expect_delimiter = false;
            last_arg_was_comment_only = false;
        }
    }

    events.push(Event::Finish); // ARG_LIST

    // Closing paren (may have trailing whitespace/newlines before it).
    let next_i = ctx.skip_ws_and_newlines(i);
    for idx in i..next_i {
        events.push(Event::Tok(idx));
    }
    i = next_i;

    if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::RParen)) {
        events.push(Event::Tok(i));
        i += 1;
    } else if let Some(tok) = tokens.get(lparen_idx) {
        push_token_diagnostic(diagnostics, "expected ')' to close function call", tok);
    }

    events.push(Event::Finish); // CALL_EXPR

    ExprParse {
        start: callee.start,
        end: i,
        events,
    }
}

fn parse_subset_expr(
    ctx: &ParserCtx<'_>,
    target: ExprParse,
    lbrack_idx: usize,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> ExprParse {
    parse_bracket_expr(
        ctx,
        target,
        lbrack_idx,
        SyntaxKind::SUBSET_EXPR,
        diagnostics,
    )
}

fn parse_subset2_expr(
    ctx: &ParserCtx<'_>,
    target: ExprParse,
    lbrack2_idx: usize,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> ExprParse {
    parse_bracket_expr(
        ctx,
        target,
        lbrack2_idx,
        SyntaxKind::SUBSET2_EXPR,
        diagnostics,
    )
}

fn parse_bracket_expr(
    ctx: &ParserCtx<'_>,
    target: ExprParse,
    open_idx: usize,
    node_kind: SyntaxKind,
    diagnostics: &mut Vec<ParseDiagnostic>,
) -> ExprParse {
    let tokens = ctx.tokens();
    let mut events = vec![Event::Start(node_kind)];
    events.extend(target.events);
    for idx in target.end..open_idx {
        events.push(Event::Tok(idx));
    }
    events.push(Event::Tok(open_idx));

    events.push(Event::Start(SyntaxKind::ARG_LIST));
    let mut i = open_idx + 1;

    let mut expect_delimiter = false;
    let mut last_arg_was_comment_only = false;
    loop {
        let next_i = ctx.skip_ws_and_newlines(i);
        let had_newline_gap = has_newline(tokens, i, next_i);
        for idx in i..next_i {
            events.push(Event::Tok(idx));
        }
        i = next_i;

        if is_matching_subset_close(tokens, i, node_kind) || tokens.get(i).is_none() {
            break;
        }

        if expect_delimiter
            && !had_newline_gap
            && let Some(tok) = tokens.get(i)
        {
            let current_is_comment = tok.kind == TokKind::Comment;
            if !current_is_comment && !last_arg_was_comment_only {
                push_token_diagnostic(diagnostics, "expected ',' between subset arguments", tok);
            }
        }

        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::Comma)) {
            events.push(Event::Start(SyntaxKind::ARG));
            events.push(Event::Finish);
            events.push(Event::Tok(i));
            i += 1;
            expect_delimiter = false;
            last_arg_was_comment_only = false;
            continue;
        }

        events.push(Event::Start(SyntaxKind::ARG));
        last_arg_was_comment_only = false;

        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::RoxygenMarker)) {
            // See `parse_call_expr`: a `#'` line inside `[`/`[[` is a comment,
            // grouped into a single comment-only ARG.
            i = crate::parser::roxygen::emit_roxygen_block(
                tokens,
                i,
                &mut events,
                ctx.md_default(),
            );
            last_arg_was_comment_only = true;
        } else if is_named_arg(ctx, i) {
            // Named subscript argument: `ident = expr` (e.g. `drop = FALSE`).
            // `=` inside `[`/`[[` is named-argument syntax, never an assignment,
            // so this parses flat (like a call argument), not as an
            // ASSIGNMENT_EXPR.
            events.push(Event::Tok(i)); // ident
            let mut eq_idx = i + 1;
            while matches!(
                tokens.get(eq_idx).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                eq_idx += 1;
            }
            for idx in (i + 1)..eq_idx {
                events.push(Event::Tok(idx));
            }
            // `is_named_arg` guarantees an `=` at `eq_idx`.
            events.push(Event::Tok(eq_idx)); // =
            let val_start = eq_idx + 1;
            let mut value_idx = val_start;
            while matches!(
                tokens.get(value_idx).map(|t| &t.kind),
                Some(TokKind::Whitespace | TokKind::Newline | TokKind::Comment)
            ) {
                value_idx += 1;
            }
            if matches!(
                tokens.get(value_idx).map(|t| &t.kind),
                Some(TokKind::Comma) | None
            ) || is_matching_subset_close(tokens, value_idx, node_kind)
            {
                // Empty value, e.g. `x[drop = ]`.
                for idx in val_start..value_idx {
                    events.push(Event::Tok(idx));
                }
                i = value_idx;
            } else if let Some(val) =
                parse_expr_in_brackets(tokens, value_idx, 0, diagnostics, ctx.md_default())
            {
                for idx in val_start..val.start {
                    events.push(Event::Tok(idx));
                }
                events.extend(val.events);
                i = val.end;
            } else {
                i = val_start;
            }
        } else if let Some(arg) =
            parse_expr_in_brackets(tokens, i, 0, diagnostics, ctx.md_default())
        {
            last_arg_was_comment_only = arg.end == arg.start + 1
                && matches!(
                    tokens.get(arg.start).map(|t| &t.kind),
                    Some(TokKind::Comment)
                );
            for idx in i..arg.start {
                events.push(Event::Tok(idx));
            }
            events.extend(arg.events);
            i = arg.end;
        } else {
            last_arg_was_comment_only = false;
            events.push(Event::Tok(i));
            i += 1;
        }
        events.push(Event::Finish);
        expect_delimiter = true;

        let next_i = ctx.skip_ws_and_newlines(i);
        for idx in i..next_i {
            events.push(Event::Tok(idx));
        }
        i = next_i;
        if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::Comma)) {
            events.push(Event::Tok(i));
            i += 1;
            expect_delimiter = false;
            last_arg_was_comment_only = false;
        }
    }

    events.push(Event::Finish); // ARG_LIST
    let next_i = ctx.skip_ws_and_newlines(i);
    for idx in i..next_i {
        events.push(Event::Tok(idx));
    }
    i = next_i;

    if is_matching_subset_close(tokens, i, node_kind) {
        match node_kind {
            SyntaxKind::SUBSET_EXPR => {
                if matches!(tokens.get(i).map(|t| &t.kind), Some(TokKind::RBrack2)) {
                    events.push(Event::Tok(i)); // consume one ] out of ]]
                    i += 1;
                } else {
                    events.push(Event::Tok(i));
                    i += 1;
                }
            }
            SyntaxKind::SUBSET2_EXPR => {
                events.push(Event::Tok(i));
                i += 1;
            }
            _ => {}
        }
    } else if node_kind == SyntaxKind::SUBSET_EXPR
        && matches!(previous_non_trivia_kind(tokens, i), Some(TokKind::RBrack2))
    {
        // `]]` may have been consumed as a single token by an inner subset node.
        // In that case, treat the outer subset close as satisfied.
    } else if let Some(tok) = tokens.get(open_idx) {
        push_token_diagnostic(
            diagnostics,
            "expected closing bracket in subset expression",
            tok,
        );
    }

    events.push(Event::Finish);
    ExprParse {
        start: target.start,
        end: i,
        events,
    }
}

fn is_matching_subset_close(tokens: &[Token], idx: usize, node_kind: SyntaxKind) -> bool {
    match node_kind {
        SyntaxKind::SUBSET_EXPR => matches!(
            tokens.get(idx).map(|t| &t.kind),
            Some(TokKind::RBrack | TokKind::RBrack2)
        ),
        SyntaxKind::SUBSET2_EXPR => {
            matches!(tokens.get(idx).map(|t| &t.kind), Some(TokKind::RBrack2))
        }
        _ => false,
    }
}

fn previous_non_trivia_kind(tokens: &[Token], mut idx: usize) -> Option<TokKind> {
    if idx == 0 {
        return None;
    }
    idx -= 1;
    loop {
        let tok = tokens.get(idx)?;
        if !matches!(tok.kind, TokKind::Whitespace | TokKind::Newline) {
            return Some(tok.kind.clone());
        }
        if idx == 0 {
            return None;
        }
        idx -= 1;
    }
}

/// The extract/namespace operators (`$`, `@`, `::`, `:::`). They tie with the
/// postfix operators (`[`, `[[`, `(`) for the highest precedence and are
/// left-associative, so their RHS is parsed as a bare member (see the infix
/// loop) to keep `a$b[c]` == `(a$b)[c]`.
fn is_extract_operator(kind: &TokKind) -> bool {
    matches!(
        kind,
        TokKind::Dollar | TokKind::At | TokKind::Colon2 | TokKind::Colon3
    )
}

fn infix_binding_power(kind: &TokKind) -> Option<(u8, u8)> {
    match kind {
        TokKind::Question => Some((0, 1)),
        TokKind::Or | TokKind::Or2 => Some((50, 51)),
        TokKind::And | TokKind::And2 => Some((60, 61)),
        TokKind::Equal2
        | TokKind::NotEqual
        | TokKind::LessThan
        | TokKind::LessThanOrEqual
        | TokKind::GreaterThan
        | TokKind::GreaterThanOrEqual => Some((80, 81)),
        TokKind::Plus | TokKind::Minus => Some((90, 91)),
        TokKind::Star | TokKind::Slash => Some((100, 101)),
        TokKind::Pipe | TokKind::UserOp => Some((110, 111)),
        TokKind::Colon => Some((120, 121)),
        TokKind::Tilde => Some((40, 41)),
        TokKind::Caret => Some((140, 140)),
        TokKind::Colon2 | TokKind::Colon3 | TokKind::Dollar | TokKind::At => Some((150, 151)),
        _ => None,
    }
}