luau-parser 0.2.68

A blazingly fast Luau parser with robust error recovery.
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

//! All `impl` blocks for table access-related types:
//!
//! * [`TableAccessPrefix`]
//! * [`TableAccessKey`]
//! * [`TableAccess`]

use luau_lexer::prelude::{Error, Lexer, Symbol, Token, TokenType};

use crate::{
    handle_error_token,
    types::{
        ExpressionWrap, FunctionCall, Parse, ParseWithArgs, Pointer, TableAccess, TableAccessKey,
        TableAccessPrefix, TableKey, TryParse,
    },
};

impl Parse for TableAccessPrefix {
    fn parse(token: Token, lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
        match token.token_type {
            TokenType::Error(error) => handle_error_token!(errors, error),
            TokenType::Identifier(_) | TokenType::PartialKeyword(_) => {
                FunctionCall::parse(token.clone(), lexer, errors).or(Some(Self::Name(token)))
            }
            TokenType::Symbol(Symbol::OpeningParenthesis) => ExpressionWrap::parse_with(
                token,
                lexer,
                errors,
                ("Expected <expr>", Symbol::ClosingParenthesis),
            )
            .map(Pointer::new)
            .map(Self::ExpressionWrap),
            _ => None,
        }
    }
}
impl TryParse for TableAccessPrefix {}

impl Parse for TableAccessKey {
    fn parse(maybe_dot: Token, lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
        Self::parse_with(maybe_dot, lexer, errors, true)
    }
}
impl TryParse for TableAccessKey {}

impl ParseWithArgs<bool> for TableAccessKey {
    fn parse_with(
        token: Token,
        lexer: &mut Lexer,
        errors: &mut Vec<Error>,
        accept_expression: bool,
    ) -> Option<Self> {
        match token.token_type {
            TokenType::Error(error) => handle_error_token!(errors, error),
            TokenType::Symbol(Symbol::Dot) => {
                next_token_recoverable!(
                    lexer,
                    name,
                    TokenType::Identifier(_) | TokenType::PartialKeyword(_),
                    TokenType::Identifier("*error*".into()),
                    errors,
                    "Expected <ident>"
                );

                Some(Self::Name {
                    dot: Pointer::new(token),
                    name: Pointer::new(name),
                })
            }
            _ if accept_expression && token == TokenType::Symbol(Symbol::OpeningBrackets) => {
                TableKey::parse_with(token, lexer, errors, false)
                    .map(Pointer::new)
                    .map(Self::Expression)
            }
            _ => None,
        }
    }
}

impl Parse for TableAccess {
    fn parse(token: Token, lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
        Some(Self {
            prefix: TableAccessPrefix::parse(token, lexer, errors)?,
            accessed_keys: Vec::<TableAccessKey>::try_parse(lexer, errors)?,
        })
    }
}
impl TryParse for TableAccess {
    fn try_parse(lexer: &mut Lexer, errors: &mut Vec<Error>) -> Option<Self> {
        Some(Self {
            prefix: TableAccessPrefix::try_parse(lexer, errors)?,
            accessed_keys: Vec::<TableAccessKey>::try_parse(lexer, errors)?,
        })
    }
}