luau_parser/impl/
bracketed.rs

1//! All `impl` blocks for [`Bracketed`].
2
3use luau_lexer::prelude::{Lexer, ParseError, State, Symbol, Token, TokenType};
4use std::ops::{Deref, DerefMut};
5
6use crate::{
7    types::{Bracketed, List, Parse, ParseWithArgs, Print, TryParse, TryParseWithArgs},
8    utils::get_token_type_display_extended,
9};
10
11impl<T: Default> Bracketed<T> {
12    /// The actual parsing logic.
13    fn parse<F>(
14        previous_state: State,
15        parse: F,
16        opening_bracket: Token,
17        lexer: &mut Lexer,
18        errors: &mut Vec<ParseError>,
19        (error_message, stop_at): (&str, Symbol),
20    ) -> Option<Self>
21    where
22        F: FnOnce(Token, &mut Lexer, &mut Vec<ParseError>) -> Option<T>,
23    {
24        let token = lexer.next_token();
25        if token == TokenType::Symbol(stop_at) {
26            return Some(Self {
27                opening_bracket,
28                item: T::default(),
29                closing_bracket: token,
30            });
31        }
32
33        let Some(item) = parse(token, lexer, errors) else {
34            let state = lexer.save_state();
35            errors.push(ParseError::new(
36                state.lexer_position(),
37                error_message.to_string(),
38                Some(state.lexer_position()),
39            ));
40
41            return None;
42        };
43
44        next_token_recoverable_with_condition!(
45            lexer,
46            closing_bracket,
47            closing_bracket.token_type == TokenType::Symbol(stop_at),
48            TokenType::Symbol(stop_at),
49            errors,
50            format!(
51                "Expected {}",
52                get_token_type_display_extended(&TokenType::Symbol(stop_at))
53            )
54        );
55
56        Some(Self {
57            opening_bracket,
58            item,
59            closing_bracket,
60        })
61    }
62}
63
64impl<T: Parse + Default> ParseWithArgs<(&str, Symbol)> for Bracketed<T> {
65    #[inline]
66    fn parse_with(
67        opening_bracket: Token,
68        lexer: &mut Lexer,
69        errors: &mut Vec<ParseError>,
70        (error_message, stop_at): (&str, Symbol),
71    ) -> Option<Self> {
72        Self::parse(
73            lexer.save_state(),
74            |token: Token, lexer: &mut Lexer, errors: &mut Vec<ParseError>| {
75                T::parse(token, lexer, errors)
76            },
77            opening_bracket,
78            lexer,
79            errors,
80            (error_message, stop_at),
81        )
82    }
83}
84impl<A, T> ParseWithArgs<(&str, Symbol, A)> for Bracketed<T>
85where
86    T: ParseWithArgs<A> + Default,
87{
88    #[inline]
89    fn parse_with(
90        opening_bracket: Token,
91        lexer: &mut Lexer,
92        errors: &mut Vec<ParseError>,
93        (error_message, stop_at, args): (&str, Symbol, A),
94    ) -> Option<Self> {
95        Self::parse(
96            lexer.save_state(),
97            |token: Token, lexer: &mut Lexer, errors: &mut Vec<ParseError>| {
98                T::parse_with(token, lexer, errors, args)
99            },
100            opening_bracket,
101            lexer,
102            errors,
103            (error_message, stop_at),
104        )
105    }
106}
107
108impl<T> Deref for Bracketed<T> {
109    type Target = T;
110
111    fn deref(&self) -> &Self::Target {
112        &self.item
113    }
114}
115
116impl<T> DerefMut for Bracketed<T> {
117    fn deref_mut(&mut self) -> &mut Self::Target {
118        &mut self.item
119    }
120}
121
122impl<T: Print> Print for Bracketed<T> {
123    fn print_final_trivia(&self) -> String {
124        self.closing_bracket.print_final_trivia()
125    }
126
127    fn print_without_final_trivia(&self) -> String {
128        self.opening_bracket.print_without_final_trivia()
129            + &self.item.print_without_final_trivia()
130            + &self.closing_bracket.print_without_final_trivia()
131    }
132}
luau_parser/impl/bracketed.rs

luau_parser/impl/
bracketed.rs
