luaur-ast 0.1.1

Lexer, parser, and AST for Luau (faithful Rust port).
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

use crate::enums::type_lexer::Type;
use crate::records::ast_expr::AstExpr;
use crate::records::ast_expr_group::AstExprGroup;
use crate::records::cst_expr_group::CstExprGroup;
use crate::records::location::Location;
use crate::records::match_lexeme::MatchLexeme;
use crate::records::parser::Parser;
use crate::records::position::Position;

impl Parser {
    pub fn parse_prefix_expr(&mut self) -> *mut AstExpr {
        if self.lexer.current().r#type == Type('(' as i32) {
            let start = self.lexer.current().location.begin;
            let match_paren = MatchLexeme::new(self.lexer.current());
            self.next_lexeme();

            let expr = self.parse_expr_i32(0);
            let mut end = self.lexer.current().location.end;
            let mut close_paren_found = false;

            if self.lexer.current().r#type != Type(')' as i32) {
                let suggestion = if self.lexer.current().r#type == Type('=' as i32) {
                    Some("; did you mean to use '{' when defining a table?")
                } else {
                    None
                };

                self.expect_match_and_consume_fail(Type(')' as i32), &match_paren, suggestion);
                end = self.lexer.previous_location().end;
            } else {
                close_paren_found = true;
                self.next_lexeme();
            }

            let expr_group = unsafe {
                (*self.allocator).alloc(AstExprGroup::new(Location::new(start, end), expr))
            };

            if luaur_common::FFlag::LuauCstExprGroup.get() && self.options.store_cst_data {
                let close_pos = if close_paren_found {
                    self.lexer.previous_location().begin
                } else {
                    Position::missing()
                };
                let cst_node = unsafe { (*self.allocator).alloc(CstExprGroup::new(close_pos)) };
                self.cst_node_map.try_insert(
                    expr_group as *mut crate::records::ast_node::AstNode,
                    cst_node as *mut crate::records::cst_node::CstNode,
                );
            }

            expr_group as *mut AstExpr
        } else {
            self.parse_name_expr("expression")
        }
    }
}