mago-syntax 1.20.1

A correct, fast, and memory-efficient PHP syntax implementation, including Lexer, Parser, AST, and utilities for Mago.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use mago_database::file::HasFileId;
use mago_span::HasSpan;
use mago_span::Span;

use crate::T;
use crate::ast::sequence::TokenSeparatedSequence;
use crate::error::ParseError;
use crate::parser::Parser;
use crate::token::TokenKind;

/// Result of parsing a token separated sequence.
pub struct TokenSeparatedSequenceResult<'arena, T> {
    /// The opening delimiter span.
    pub open: Span,
    /// The parsed elements and their separators.
    pub sequence: TokenSeparatedSequence<'arena, T>,
    /// The closing delimiter span.
    pub close: Span,
}

impl<'input, 'arena> Parser<'input, 'arena> {
    /// Parse a comma-separated sequence.
    ///
    /// This method handles common patterns like:
    /// - `(a, b, c)` - argument lists
    /// - `[1, 2, 3]` - arrays
    /// - `{a, b}` - various constructs
    #[inline(always)]
    pub(crate) fn parse_comma_separated_sequence<T, F>(
        &mut self,
        open_kind: TokenKind,
        close_kind: TokenKind,
        parse_element: F,
    ) -> Result<TokenSeparatedSequenceResult<'arena, T>, ParseError>
    where
        T: HasSpan,
        F: FnMut(&mut Self) -> Result<T, ParseError>,
    {
        self.parse_token_separated_sequence(open_kind, close_kind, T![","], parse_element)
    }

    /// Parse a token-separated sequence.
    ///
    /// This method handles common patterns like:
    /// - `(a, b, c)` - argument lists
    /// - `[1, 2, 3]` - arrays
    /// - `{a, b}` - various constructs
    #[inline]
    pub(crate) fn parse_token_separated_sequence<T, F>(
        &mut self,
        open_kind: TokenKind,
        close_kind: TokenKind,
        separator_kind: TokenKind,
        mut parse_element: F,
    ) -> Result<TokenSeparatedSequenceResult<'arena, T>, ParseError>
    where
        T: HasSpan,
        F: FnMut(&mut Self) -> Result<T, ParseError>,
    {
        let open = self.stream.eat_span(open_kind)?;

        let mut elements = self.new_vec();
        let mut separators = self.new_vec();

        loop {
            match self.stream.peek_kind(0)? {
                Some(kind) if kind == close_kind => break,
                None => return Err(self.stream.unexpected(None, &[close_kind])),
                _ => {}
            }

            match parse_element(self) {
                Ok(element) => elements.push(element),
                Err(err) => {
                    self.errors.push(err);
                }
            }

            match self.stream.peek_kind(0)? {
                Some(kind) if kind == separator_kind => separators.push(self.stream.consume()?),
                _ => break,
            }
        }

        let Some(current) = self.stream.lookahead(0)? else {
            return Err(self.stream.unexpected(None, &[close_kind]));
        };

        if current.kind == close_kind {
            self.stream.consume()?;
        } else {
            self.errors.push(self.stream.unexpected(Some(current), &[close_kind]));
        }

        Ok(TokenSeparatedSequenceResult {
            open,
            sequence: TokenSeparatedSequence::new(elements, separators),
            close: current.span_for(self.stream.file_id()),
        })
    }
}