mago_syntax/parser/

mod.rs

use mago_allocator::prelude::*;

use mago_database::file::File;
use mago_database::file::FileId;
use mago_database::file::HasFileId;
use mago_syntax_core::input::Input;

use crate::cst::Program;
use crate::cst::sequence::Sequence;
use crate::error::ParseError;
use crate::lexer::Lexer;
use crate::parser::stream::TokenStream;
use crate::settings::ParserSettings;

mod internal;

pub mod stream;

/// Maximum recursion depth for expression parsing.
/// This prevents stack overflow on deeply nested expressions and statements.
const MAX_RECURSION_DEPTH: u16 = 512;

#[derive(Debug, Default)]
pub struct State {
    pub within_string_interpolation: bool,
    pub recursion_depth: u16,
}

/// The main parser for PHP source code.
///
/// The parser holds an arena reference, the token stream, and parsing state.
#[derive(Debug)]
#[allow(clippy::field_scoped_visibility_modifiers)]
pub struct Parser<'input, 'arena, A>
where
    'input: 'arena,
    A: Arena,
{
    pub(crate) arena: &'arena A,
    pub(crate) state: State,
    pub(crate) stream: TokenStream<'input, 'arena, A>,
    pub(crate) errors: Vec<'arena, ParseError, A>,
}

impl<'input, 'arena, A> Parser<'input, 'arena, A>
where
    A: Arena,
{
    /// Creates a new parser for the given content.
    ///
    /// # Parameters
    ///
    /// - `arena`: The memory arena for allocations.
    /// - `file_id`: The ID of the file being parsed.
    /// - `content`: The content to parse.
    /// - `settings`: The parser settings.
    ///
    /// # Returns
    ///
    /// A new `Parser` instance.
    #[inline]
    pub fn new(arena: &'arena A, file_id: FileId, content: &'input [u8], settings: ParserSettings) -> Self {
        let input = Input::new(file_id, content);
        let lexer = Lexer::new(input, settings.lexer);
        let stream = TokenStream::new(arena, lexer);

        Self { arena, state: State::default(), stream, errors: Vec::new_in(arena) }
    }

    /// Creates a new parser for the given file.
    ///
    /// # Parameters
    ///
    /// - `arena`: The memory arena for allocations.
    /// - `file`: The file to parse.
    /// - `settings`: The parser settings.
    ///
    /// # Returns
    ///
    /// A new `Parser` instance.
    pub fn for_file(arena: &'arena A, file: &'input File, settings: ParserSettings) -> Self {
        Self::new(arena, file.file_id(), file.contents.as_ref(), settings)
    }

    /// Parses and returns the program AST.
    fn parse(mut self, source_text: &'arena [u8], file_id: FileId) -> &'arena Program<'arena> {
        let mut statements = Vec::new_in(self.arena);

        loop {
            let reached_eof = match self.stream.has_reached_eof() {
                Ok(eof) => eof,
                Err(err) => {
                    self.errors.push(ParseError::from(err));
                    break;
                }
            };

            if reached_eof {
                break;
            }

            // Record position before parsing to detect infinite loops
            let position_before = self.stream.current_position();

            match self.parse_statement() {
                Ok(statement) => statements.push(statement),
                Err(err) => self.errors.push(err),
            }

            // Safety check: if we didn't advance at all, skip a token to prevent infinite loop.
            // This can happen with orphan keywords like `finally`, `catch`, `else`, etc.
            // that are preserved by the expression parser but not handled by the statement parser.
            let position_after = self.stream.current_position();
            if position_after == position_before
                && let Ok(Some(token)) = self.stream.lookahead(0)
            {
                self.errors.push(self.stream.unexpected(Some(token), &[]));
                let _ = self.stream.consume();
            }
        }

        self.arena.alloc(Program {
            file_id,
            source_text,
            statements: Sequence::new(statements),
            trivia: self.stream.get_trivia(),
            errors: self.errors.leak(),
        })
    }
}

/// Parses the given file and returns the program AST.
///
/// # Parameters
///
/// - `arena`: The memory arena for allocations.
/// - `file`: The file to parse.
///
/// # Returns
///
/// The parsed `Program` AST.
#[inline]
pub fn parse_file<'arena, A>(arena: &'arena A, file: &File) -> &'arena Program<'arena>
where
    A: Arena,
{
    parse_file_content(arena, file.file_id(), file.contents.as_ref())
}

/// Parses the given file with custom settings and returns the program AST.
///
/// # Parameters
///
/// - `arena`: The memory arena for allocations.
/// - `file`: The file to parse.
/// - `settings`: The parser settings.
///
/// # Returns
///
/// The parsed `Program` AST.
#[inline]
pub fn parse_file_with_settings<'arena, A>(
    arena: &'arena A,
    file: &File,
    settings: ParserSettings,
) -> &'arena Program<'arena>
where
    A: Arena,
{
    parse_file_content_with_settings(arena, file.file_id(), file.contents.as_ref(), settings)
}

/// Parses the given file content and returns the program AST.
///
/// # Parameters
///
/// - `arena`: The memory arena for allocations.
/// - `file_id`: The ID of the file being parsed.
/// - `content`: The content to parse.
///
/// # Returns
///
/// The parsed `Program` AST.
pub fn parse_file_content<'arena, A>(arena: &'arena A, file_id: FileId, content: &[u8]) -> &'arena Program<'arena>
where
    A: Arena,
{
    let source_text = arena.alloc_slice_copy(content);
    Parser::new(arena, file_id, source_text, ParserSettings::default()).parse(source_text, file_id)
}

/// Parses the given file content with custom settings and returns the program AST.
///
/// # Parameters
///
/// - `arena`: The memory arena for allocations.
/// - `file_id`: The ID of the file being parsed.
/// - `content`: The content to parse.
/// - `settings`: The parser settings.
///
/// # Returns
///
/// The parsed `Program` AST.
pub fn parse_file_content_with_settings<'arena, A>(
    arena: &'arena A,
    file_id: FileId,
    content: &[u8],
    settings: ParserSettings,
) -> &'arena Program<'arena>
where
    A: Arena,
{
    let source_text = arena.alloc_slice_copy(content);
    Parser::new(arena, file_id, source_text, settings).parse(source_text, file_id)
}