luau_parser/impl/block/
set_expressions.rs

1//! All `impl` blocks for:
2//!
3//! * [`SetExpression`]
4//! * [`CompoundSetExpression`]
5
6use luau_lexer::prelude::{Error, Lexer, Symbol, Token, TokenType};
7
8use crate::{
9    safe_unwrap,
10    types::{
11        CompoundSetExpression, Expression, List, Parse, Pointer, SetExpression, TryParse, Var,
12    },
13};
14
15impl Parse for SetExpression {
16    fn parse(token: Token, lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
17        let state = lexer.save_state();
18
19        if !matches!(
20            token.token_type,
21            TokenType::PartialKeyword(_) | TokenType::Identifier(_)
22        ) {
23            return None;
24        }
25
26        let variables = safe_unwrap!(
27            lexer,
28            errors,
29            "Expected <name>",
30            List::parse(token, lexer, errors)
31        );
32        maybe_next_token!(lexer, equal, TokenType::Symbol(Symbol::Equal));
33        let Some(equal) = equal else {
34            lexer.set_state(state);
35
36            return None;
37        };
38
39        let values = safe_unwrap!(
40            lexer,
41            errors,
42            "Expected <expr>",
43            List::try_parse(lexer, errors)
44        );
45
46        Some(Self {
47            variables,
48            equal,
49            values,
50        })
51    }
52}
53
54impl Parse for CompoundSetExpression {
55    fn parse(token: Token, lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
56        let state = lexer.save_state();
57        if !matches!(
58            token.token_type,
59            TokenType::PartialKeyword(_) | TokenType::Identifier(_)
60        ) {
61            return None;
62        }
63
64        let variable = safe_unwrap!(
65            lexer,
66            errors,
67            "Expected <name>",
68            Var::parse(token, lexer, errors)
69        );
70        maybe_next_token!(lexer, operation, TokenType::CompoundOperator(_));
71        let Some(operation) = operation else {
72            lexer.set_state(state);
73
74            return None;
75        };
76
77        let value = safe_unwrap!(
78            lexer,
79            errors,
80            "Expected <expr>",
81            Pointer::<Expression>::try_parse(lexer, errors)
82        );
83
84        Some(Self {
85            variable,
86            operation,
87            value,
88        })
89    }
90}