symboscript_parser/parser/
mod.rs

1use symboscript_lexer::Lexer;
2use symboscript_types::{
3    lexer::{Token, TokenKind, TokenValue},
4    parser::*,
5};
6use symboscript_utils::report_error;
7
8#[macro_use]
9mod macro_utils;
10
11pub struct Parser<'a> {
12    /// Path of the source file
13    path: &'a str,
14
15    /// Source Text
16    source: &'a str,
17
18    /// Lexer
19    lexer: Lexer<'a>,
20
21    cur_token: Token,
22
23    prev_token_end: usize,
24}
25
26impl<'a> Parser<'a> {
27    pub fn new(path: &'a str, source: &'a str) -> Self {
28        Self {
29            path,
30            source,
31            lexer: Lexer::new(path, source, false),
32            cur_token: Token::default(),
33            prev_token_end: 0,
34        }
35    }
36
37    pub fn parse(&mut self) -> Ast {
38        self.eat(TokenKind::Start);
39        return Ast {
40            program: self.program(),
41        };
42    }
43
44    // -------------------- program ------------------------
45
46    fn program(&mut self) -> Program {
47        Program {
48            node: Node {
49                start: 0,
50                end: self.source.len(),
51            },
52            body: self.body(),
53        }
54    }
55
56    fn body(&mut self) -> Vec<Statement> {
57        let mut body = vec![];
58
59        loop {
60            match self.cur_kind() {
61                TokenKind::Eof | TokenKind::RAngle => break,
62                _ => {
63                    body.push(self.statement());
64                }
65            }
66        }
67
68        body
69    }
70
71    // -------------------- statements ---------------------
72
73    fn statement(&mut self) -> Statement {
74        match self.cur_kind() {
75            TokenKind::Let => self.var_decl(false),
76            TokenKind::Function | TokenKind::Async => self.fn_decl(),
77            TokenKind::Scope => self.scope_decl(),
78            TokenKind::Context => self.context_decl(),
79
80            TokenKind::If => self.if_stmt(),
81
82            TokenKind::For => self.for_stmt(),
83            TokenKind::While => self.while_stmt(),
84            TokenKind::Loop => self.loop_stmt(),
85
86            TokenKind::Continue => self.continue_stmt(),
87            TokenKind::Break => self.break_stmt(),
88
89            TokenKind::Throw => self.throw_stmt(),
90
91            TokenKind::Return => self.return_stmt(),
92            TokenKind::Yield => self.yield_stmt(),
93
94            TokenKind::Import => self.import_statement(),
95
96            TokenKind::Block => self.block_decl(),
97            TokenKind::LAngle => Statement::BlockStatement(self.block_stmt()),
98
99            TokenKind::Mut => self.assign_statement(),
100
101            _ => self.expr_stmt(),
102        }
103    }
104
105    fn block_stmt(&mut self) -> Vec<Statement> {
106        let mut body = vec![];
107
108        if self.cur_kind() == TokenKind::LAngle {
109            body = {
110                let start = self.cur_token.start;
111                self.eat(TokenKind::LAngle);
112                let consequent = self.body();
113                self.eat_with_start(TokenKind::RAngle, start);
114                consequent
115            }
116        } else {
117            body.push(self.statement());
118        }
119
120        return body;
121    }
122
123    // --------------- import statement ----------------
124
125    fn import_statement(&mut self) -> Statement {
126        let start = self.cur_token.start;
127        self.advance();
128
129        let source = Identifier {
130            node: Node::new(self.cur_token.start, self.cur_token.end),
131            name: match self.cur_token.value.clone() {
132                TokenValue::Str(s) => s,
133                TokenValue::Identifier(s) => s,
134                got => {
135                    self.report_expected(self.cur_token.start, "Identifier or String", got);
136                    unreachable!("Report ends proccess");
137                }
138            },
139        };
140
141        self.advance();
142
143        let as_name = match self.cur_kind() {
144            TokenKind::As => {
145                self.advance();
146
147                let id = Identifier {
148                    node: Node::new(self.cur_token.start, self.cur_token.end),
149                    name: format!("{}", self.cur_token.clone().value),
150                };
151
152                self.eat(TokenKind::Identifier);
153
154                id
155            }
156
157            _ => source.clone(),
158        };
159
160        self.eat(TokenKind::Semicolon);
161
162        Statement::ImportStatement(uni_builder!(
163            self,
164            ImportStatement,
165            start,
166            [source, as_name]
167        ))
168    }
169
170    // --------------- scope declaration ---------------
171
172    fn scope_decl(&mut self) -> Statement {
173        let start = self.cur_token.start;
174        self.eat(TokenKind::Scope);
175
176        let id = format!("{}", self.cur_token.clone().value);
177        self.eat(TokenKind::Identifier);
178
179        let body = self.block_stmt();
180
181        Statement::ScopeDeclaration(uni_builder!(self, ScopeDeclarator, start, [id, body]))
182    }
183
184    fn context_decl(&mut self) -> Statement {
185        let start = self.cur_token.start;
186        self.eat(TokenKind::Context);
187
188        let id = format!("{}", self.cur_token.clone().value);
189        self.eat(TokenKind::Identifier);
190
191        let body = self.block_stmt();
192
193        Statement::ContextDeclaration(uni_builder!(self, ContextDeclarator, start, [id, body]))
194    }
195
196    // --------------- loop statement ------------------
197
198    fn loop_stmt(&mut self) -> Statement {
199        let start = self.cur_token.start;
200        self.eat(TokenKind::Loop);
201        let body = self.block_stmt();
202
203        Statement::LoopStatement(uni_builder!(self, LoopStatement, start, [body]))
204    }
205
206    // --------------- while statement ------------------
207
208    fn while_stmt(&mut self) -> Statement {
209        let start = self.cur_token.start;
210        self.eat(TokenKind::While);
211
212        let test = {
213            let start = self.cur_token.start;
214            self.eat(TokenKind::LParen);
215            let test = self.expr();
216            self.eat_with_start(TokenKind::RParen, start);
217            test
218        };
219
220        let body = self.block_stmt();
221
222        Statement::WhileStatement(uni_builder!(self, WhileStatement, start, [test, body]))
223    }
224
225    // --------------- for statement ------------------
226
227    fn for_stmt(&mut self) -> Statement {
228        let start = self.cur_token.start;
229
230        self.eat(TokenKind::For);
231        self.eat(TokenKind::LParen);
232
233        let init = self.var_decl(true);
234
235        let test = {
236            let start = self.cur_token.start;
237            let test = self.expr();
238            self.eat_with_start(TokenKind::Semicolon, start);
239            test
240        };
241
242        let update = {
243            let start = self.cur_token.start;
244            let update = self.expr();
245            self.eat_with_start(TokenKind::RParen, start);
246            update
247        };
248
249        let body = self.block_stmt();
250
251        Statement::ForStatement(Box::new(uni_builder!(
252            self,
253            ForStatement,
254            start,
255            [init, test, update, body]
256        )))
257    }
258
259    // --------------- if statement -------------------
260
261    fn if_stmt(&mut self) -> Statement {
262        let start = self.cur_token.start;
263
264        self.eat(TokenKind::If);
265
266        let test = {
267            let start = self.cur_token.start;
268            self.eat(TokenKind::LParen);
269            let test = self.expr();
270            self.eat_with_start(TokenKind::RParen, start);
271            test
272        };
273
274        let consequent = self.block_stmt();
275
276        let mut alternate = vec![];
277
278        if self.cur_kind() == TokenKind::Else {
279            self.advance();
280            alternate = self.block_stmt();
281        }
282
283        Statement::IfStatement(uni_builder!(
284            self,
285            IfStatement,
286            start,
287            [test, consequent, alternate]
288        ))
289    }
290
291    // -------------- word statements -----------------
292
293    fn return_stmt(&mut self) -> Statement {
294        word_stmt!(self, TokenKind::Return, ReturnStatement)
295    }
296
297    fn yield_stmt(&mut self) -> Statement {
298        word_stmt!(self, TokenKind::Yield, YieldStatement)
299    }
300
301    fn throw_stmt(&mut self) -> Statement {
302        word_stmt!(self, TokenKind::Throw, ThrowStatement)
303    }
304
305    fn block_decl(&mut self) -> Statement {
306        self.advance();
307
308        Statement::BlockStatement(self.block_stmt())
309    }
310
311    fn continue_stmt(&mut self) -> Statement {
312        let start = self.cur_token.start;
313        self.eat(TokenKind::Continue);
314
315        Statement::ContinueStatement(Node::new(start, self.cur_token.end))
316    }
317
318    fn break_stmt(&mut self) -> Statement {
319        let start = self.cur_token.start;
320        self.eat(TokenKind::Break);
321
322        Statement::BreakStatement(Node::new(start, self.cur_token.end))
323    }
324
325    // --------------- function declaration -----------------
326
327    fn fn_decl(&mut self) -> Statement {
328        let start = self.cur_token.start;
329
330        let is_async = {
331            if self.cur_kind() == TokenKind::Async {
332                self.eat(TokenKind::Async);
333                true
334            } else {
335                false
336            }
337        };
338
339        self.advance();
340
341        let id = format!("{}", self.cur_token.clone().value);
342        self.eat(TokenKind::Identifier);
343
344        let params = {
345            let start = self.cur_token.start;
346
347            self.eat(TokenKind::LSquare);
348
349            let params = self
350                .parse_params()
351                .into_iter()
352                .map(|p| format!("{}", p.value))
353                .collect();
354
355            self.eat_with_start(TokenKind::RSquare, start);
356            params
357        };
358
359        let body = self.block_stmt();
360
361        Statement::FunctionDeclaration(uni_builder!(
362            self,
363            FunctionDeclarator,
364            start,
365            [id, params, body, is_async]
366        ))
367    }
368
369    fn parse_params(&mut self) -> Vec<Token> {
370        let mut params = vec![];
371
372        if self.cur_kind() == TokenKind::RSquare {
373            // self.advance();
374            return params;
375        }
376
377        params.push(self.cur_token.clone());
378        self.eat(TokenKind::Identifier);
379
380        while self.cur_kind() == TokenKind::Comma {
381            self.advance();
382            params.push(self.cur_token.clone());
383            self.eat(TokenKind::Identifier);
384        }
385
386        params
387    }
388
389    // -------------- variable declaration -----------------
390
391    fn var_decl(&mut self, only_with_init: bool) -> Statement {
392        let start = self.cur_token.start;
393        self.advance();
394
395        let id = format!("{}", self.cur_token.clone().value);
396        self.eat(TokenKind::Identifier);
397
398        let mut is_formula = false;
399
400        let init = {
401            let start = self.cur_token.start;
402
403            match self.cur_kind() {
404                TokenKind::Assign => {
405                    self.advance();
406                    self.expr()
407                }
408                TokenKind::FormulaAssign => {
409                    is_formula = true;
410                    self.advance();
411                    self.expr()
412                }
413                _ if !only_with_init => Expression::None(None {
414                    node: Node::new(start, self.cur_token.end),
415                }),
416                _ => {
417                    self.report_expected(start, "Assign or FormulaAssign", self.cur_kind());
418                    unreachable!("Report ends proccess");
419                }
420            }
421        };
422
423        self.eat(TokenKind::Semicolon);
424
425        Statement::VariableDeclaration(uni_builder!(
426            self,
427            VariableDeclarator,
428            start,
429            [id, init, is_formula]
430        ))
431    }
432
433    // ---------------- assign statement -------------------
434
435    ///ternary (Assign | PlusAssign | MinusAssign | MultiplyAssign | DivideAssign | PowerAssign | ModuloAssign) ternary
436    fn assign_statement(&mut self) -> Statement {
437        let start = self.cur_token.start;
438
439        self.eat(TokenKind::Mut);
440
441        let left = self.cur_token.clone();
442        self.eat(TokenKind::Identifier);
443
444        let left = Identifier {
445            node: Node::new(start, self.cur_token.end),
446            name: format!("{}", left.value),
447        };
448
449        if [
450            TokenKind::Assign,
451            TokenKind::PlusAssign,
452            TokenKind::MinusAssign,
453            TokenKind::MultiplyAssign,
454            TokenKind::DivideAssign,
455            TokenKind::PowerAssign,
456            TokenKind::ModuloAssign,
457        ]
458        .contains(&self.cur_token.kind)
459        {
460            let current_token = self.cur_token.clone();
461
462            self.advance();
463
464            let right = self.expr();
465            let operator = self.kind_to_assign_op(current_token.kind);
466
467            self.eat(TokenKind::Semicolon);
468            Statement::AssignStatement(uni_builder!(
469                self,
470                AssignStatement,
471                start,
472                [left, right, operator]
473            ))
474        } else {
475            self.report_expected(start, "= | += | -= | *= | /= | ^= | %=", self.cur_kind());
476            unreachable!("Report ends proccess");
477        }
478    }
479
480    // -------------------- expressions --------------------
481
482    fn expr_stmt(&mut self) -> Statement {
483        let expression = self.expr();
484        self.eat(TokenKind::Semicolon);
485
486        Statement::ExpressionStatement(expression)
487    }
488
489    /// full expression
490    fn expr(&mut self) -> Expression {
491        self.comma(false)
492    }
493
494    /// word_expression , word_expression | word_expression
495    fn comma(&mut self, only_sequence: bool) -> Expression {
496        let start = self.cur_token.start;
497        let mut nodes = vec![];
498
499        nodes.push(self.ternary());
500        while self.cur_kind() == TokenKind::Comma {
501            self.advance();
502            nodes.push(self.ternary());
503        }
504
505        if !only_sequence && nodes.len() == 1 {
506            return nodes[0].clone();
507        }
508
509        self.sequence_expression(start, nodes)
510    }
511
512    /// range ? range : range | range
513    fn ternary(&mut self) -> Expression {
514        let start = self.cur_token.start;
515        let mut node = self.range();
516
517        while self.cur_kind() == TokenKind::Question {
518            self.advance();
519            let consequent = self.range();
520            self.eat(TokenKind::Colon);
521
522            let alternate = self.expr();
523
524            node = self.conditional_expression(start, node, consequent, alternate);
525        }
526
527        node
528    }
529
530    /// logical_or .. logical_or | logical_or
531    fn range(&mut self) -> Expression {
532        binary_left_associative!(self, [TokenKind::Range], logical_or)
533    }
534
535    /// logical_and || logical_and
536    fn logical_or(&mut self) -> Expression {
537        binary_left_associative!(self, [TokenKind::PipePipe], logical_and)
538    }
539
540    /// cmp && cmp
541    fn logical_and(&mut self) -> Expression {
542        binary_left_associative!(self, [TokenKind::AmpersandAmpersand], cmp)
543    }
544
545    /// bit_or (< | <= | > | >= | == | !=) bit_or
546    fn cmp(&mut self) -> Expression {
547        binary_left_associative!(
548            self,
549            [
550                TokenKind::Less,
551                TokenKind::LessEqual,
552                TokenKind::Greater,
553                TokenKind::GreaterEqual,
554                TokenKind::Equal,
555                TokenKind::NotEqual,
556            ],
557            bit_or
558        )
559    }
560
561    ///bit_xor | bit_xor
562    fn bit_or(&mut self) -> Expression {
563        binary_left_associative!(self, [TokenKind::Pipe], bit_xor)
564    }
565
566    /// bit_and bxor bit_and
567    fn bit_xor(&mut self) -> Expression {
568        binary_left_associative!(self, [TokenKind::BitXor], bit_and)
569    }
570
571    /// shift & shift
572    fn bit_and(&mut self) -> Expression {
573        binary_left_associative!(self, [TokenKind::Ampersand], shift)
574    }
575
576    /// add_sub (>> | <<) add_sub
577    fn shift(&mut self) -> Expression {
578        binary_left_associative!(
579            self,
580            [TokenKind::BitRightShift, TokenKind::BitLeftShift],
581            add_sub
582        )
583    }
584
585    /// term (Plus | Minus) term
586    fn add_sub(&mut self) -> Expression {
587        binary_left_associative!(self, [TokenKind::Plus, TokenKind::Minus], term)
588    }
589
590    /// (power (Star | Slash | Modulo) power)* | (power power)*
591    fn term(&mut self) -> Expression {
592        let start = self.cur_token.start;
593        let mut expr = self.power();
594
595        while [TokenKind::Identifier, TokenKind::LParen, TokenKind::Number]
596            .contains(&self.cur_kind())
597        {
598            let right = self.power();
599            expr = self.binary_expression(start, expr, right, TokenKind::Star);
600        }
601
602        while [TokenKind::Star, TokenKind::Slash, TokenKind::Modulo].contains(&self.cur_kind()) {
603            let operator = self.cur_kind();
604            self.advance();
605
606            let right = self.power();
607
608            expr = self.binary_expression(start, expr, right, operator);
609        }
610
611        expr
612    }
613
614    /// factor (Power) factor
615    fn power(&mut self) -> Expression {
616        binary_left_associative!(self, [TokenKind::Caret], factor)
617    }
618
619    /// Number | LParen expr Rparen | Identifier | (! | ++ | -- | ~)factor
620    fn factor(&mut self) -> Expression {
621        let token = self.cur_token.clone();
622
623        match token.kind {
624            TokenKind::Number | TokenKind::Str => {
625                self.advance();
626                return Expression::Literal(Literal {
627                    node: Node::new(token.start, token.end),
628                    value: token.value,
629                });
630            }
631
632            TokenKind::True => {
633                self.advance();
634                return Expression::Literal(Literal {
635                    node: Node::new(token.start, token.end),
636                    value: TokenValue::Bool(true),
637                });
638            }
639
640            TokenKind::False => {
641                self.advance();
642                return Expression::Literal(Literal {
643                    node: Node::new(token.start, token.end),
644                    value: TokenValue::Bool(false),
645                });
646            }
647
648            TokenKind::LParen => {
649                self.advance();
650                let node = self.expr();
651                self.eat_with_start(TokenKind::RParen, token.start);
652                return node;
653            }
654
655            TokenKind::LSquare => self.read_seq_expr(token),
656
657            TokenKind::ExclamationMark
658            | TokenKind::PlusPlus
659            | TokenKind::MinusMinus
660            | TokenKind::Tilde
661            | TokenKind::Minus
662            | TokenKind::Plus => {
663                self.advance();
664
665                let right = self.factor();
666                return self.unary_expression(token.start, token.kind, right);
667            }
668            _ => return self.await_expr(),
669        }
670    }
671
672    fn read_seq_expr(&mut self, token: Token) -> Expression {
673        self.advance();
674
675        match self.cur_kind() {
676            TokenKind::RSquare => {
677                self.advance();
678                return self.sequence_expression(token.start, vec![]);
679            }
680            _ => {}
681        }
682
683        let mut node = self.comma(true);
684        self.eat_with_start(TokenKind::RSquare, token.start);
685
686        match node {
687            Expression::SequenceExpression(seq_exp) => {
688                node = self.sequence_expression(token.start, seq_exp.expressions);
689            }
690            _ => node = self.sequence_expression(token.start, vec![node]),
691        }
692
693        return node;
694    }
695
696    /// await delete_expr | delete_expr
697    fn await_expr(&mut self) -> Expression {
698        word_right_associative_expr!(self, TokenKind::Await, delete_expr, await_expr)
699    }
700
701    /// delete new_expr | new_expr
702    fn delete_expr(&mut self) -> Expression {
703        word_right_associative_expr!(self, TokenKind::Delete, dot, delete_expr)
704    }
705
706    /// call.call | call
707    fn dot(&mut self) -> Expression {
708        member_left_associative!(self, [TokenKind::Dot], call)
709    }
710
711    /// identifier[expr] | identifier
712    fn call(&mut self) -> (Expression, bool) {
713        let token = self.cur_token.clone();
714
715        match self.cur_kind() {
716            TokenKind::Identifier => {
717                self.advance();
718
719                match self.cur_kind() {
720                    TokenKind::LSquare => {
721                        let sequence_start = self.cur_token.start;
722
723                        self.advance();
724
725                        match self.cur_kind() {
726                            TokenKind::RSquare => {
727                                self.advance();
728
729                                let node = self.sequence_expression(sequence_start, vec![]);
730
731                                return (
732                                    self.call_expression(
733                                        sequence_start,
734                                        format!("{}", token.value),
735                                        node,
736                                    ),
737                                    false,
738                                );
739                            }
740                            _ => {}
741                        }
742
743                        let mut node = self.expr();
744                        self.eat_with_start(TokenKind::RSquare, token.start);
745
746                        match node {
747                            Expression::SequenceExpression(seq_exp) => {
748                                node =
749                                    self.sequence_expression(sequence_start, seq_exp.expressions);
750                            }
751                            _ => node = self.sequence_expression(sequence_start, vec![node]),
752                        }
753
754                        return (
755                            self.call_expression(token.start, format!("{}", token.value), node),
756                            false,
757                        );
758                    }
759                    _ => {
760                        return (
761                            Expression::Identifier(Identifier {
762                                node: Node::new(token.start, token.end),
763                                name: format!("{}", token.value),
764                            }),
765                            false,
766                        );
767                    }
768                }
769            }
770            TokenKind::LSquare => {
771                self.advance();
772
773                let node = self.expr();
774                self.eat_with_start(TokenKind::RSquare, token.start);
775
776                return (node, true);
777            }
778            got => {
779                self.report_expected(token.start, "Identifier or [", got);
780                unreachable!("Report ends proccess");
781            }
782        }
783    }
784
785    // ------------------------------ Expression builders ------------------------------
786
787    fn call_expression(
788        &mut self,
789        start: usize,
790        callee: String,
791        arguments: Expression,
792    ) -> Expression {
793        Expression::CallExpression(Box::new(CallExpression {
794            node: Node::new(start, self.cur_token.end),
795            callee,
796            arguments,
797        }))
798    }
799
800    fn member_expression(
801        &mut self,
802        start: usize,
803        object: Expression,
804        property: Expression,
805        is_expr: bool,
806    ) -> Expression {
807        Expression::MemberExpression(Box::new(MemberExpression {
808            node: Node::new(start, self.cur_token.end),
809            object,
810            property,
811            is_expr,
812        }))
813    }
814
815    fn sequence_expression(&mut self, start: usize, expressions: Vec<Expression>) -> Expression {
816        Expression::SequenceExpression(Box::new(SequenceExpression {
817            node: Node::new(start, self.cur_token.end),
818            expressions,
819        }))
820    }
821
822    fn conditional_expression(
823        &mut self,
824        start: usize,
825        test: Expression,
826        consequent: Expression,
827        alternate: Expression,
828    ) -> Expression {
829        Expression::ConditionalExpression(Box::new(ConditionalExpression {
830            node: Node::new(start, self.cur_token.end),
831            test,
832            consequent,
833            alternate,
834        }))
835    }
836
837    fn binary_expression(
838        &mut self,
839        start: usize,
840        left: Expression,
841        right: Expression,
842        operator: TokenKind,
843    ) -> Expression {
844        Expression::BinaryExpression(Box::new(BinaryExpression {
845            node: Node::new(start, self.cur_token.end),
846            left,
847            operator: self.kind_to_bin_op(operator),
848            right,
849        }))
850    }
851
852    fn unary_expression(
853        &mut self,
854        start: usize,
855        operator: TokenKind,
856        right: Expression,
857    ) -> Expression {
858        Expression::UnaryExpression(Box::new(UnaryExpression {
859            node: Node::new(start, self.cur_token.end),
860            operator: self.kind_to_un_op(operator),
861            right,
862        }))
863    }
864
865    // ------------------------------- Utility functions -------------------------------
866
867    fn kind_to_word_op(&mut self, kind: TokenKind) -> WordOperator {
868        match kind {
869            TokenKind::Await => WordOperator::Await,
870            TokenKind::Delete => WordOperator::Delete,
871
872            got => unreachable!("This function can't be called for other tokens: ({})", got),
873        }
874    }
875
876    fn kind_to_un_op(&mut self, kind: TokenKind) -> UnaryOperator {
877        match kind {
878            TokenKind::MinusMinus => UnaryOperator::MinusMinus,
879            TokenKind::Tilde => UnaryOperator::BitNot,
880            TokenKind::ExclamationMark => UnaryOperator::Not,
881            TokenKind::PlusPlus => UnaryOperator::PlusPlus,
882
883            TokenKind::Plus => UnaryOperator::Plus,
884            TokenKind::Minus => UnaryOperator::Minus,
885
886            got => unreachable!("This function can't be called for other tokens: ({})", got),
887        }
888    }
889
890    fn kind_to_assign_op(&mut self, kind: TokenKind) -> AssignOperator {
891        match kind {
892            TokenKind::Assign => AssignOperator::Assign,
893            TokenKind::PlusAssign => AssignOperator::PlusAssign,
894            TokenKind::MinusAssign => AssignOperator::MinusAssign,
895            TokenKind::MultiplyAssign => AssignOperator::MultiplyAssign,
896            TokenKind::DivideAssign => AssignOperator::DivideAssign,
897            TokenKind::PowerAssign => AssignOperator::PowerAssign,
898            TokenKind::ModuloAssign => AssignOperator::ModuloAssign,
899
900            got => unreachable!("This function can't be called for other tokens: ({})", got),
901        }
902    }
903
904    fn kind_to_bin_op(&mut self, kind: TokenKind) -> BinaryOperator {
905        match kind {
906            TokenKind::Plus => BinaryOperator::Add,
907            TokenKind::Minus => BinaryOperator::Substract,
908            TokenKind::Star => BinaryOperator::Multiply,
909            TokenKind::Slash => BinaryOperator::Divide,
910            TokenKind::Caret => BinaryOperator::Power,
911            TokenKind::Range => BinaryOperator::Range,
912            TokenKind::Modulo => BinaryOperator::Modulo,
913
914            TokenKind::AmpersandAmpersand => BinaryOperator::And,
915            TokenKind::PipePipe => BinaryOperator::Or,
916            TokenKind::Xor => BinaryOperator::Xor,
917
918            TokenKind::Ampersand => BinaryOperator::BitAnd,
919            TokenKind::Pipe => BinaryOperator::BitOr,
920            TokenKind::BitXor => BinaryOperator::BitXor,
921
922            TokenKind::BitLeftShift => BinaryOperator::BitLeftShift,
923            TokenKind::BitRightShift => BinaryOperator::BitRightShift,
924
925            TokenKind::Equal => BinaryOperator::Equal,
926            TokenKind::NotEqual => BinaryOperator::NotEqual,
927            TokenKind::Less => BinaryOperator::Less,
928            TokenKind::LessEqual => BinaryOperator::LessEqual,
929            TokenKind::Greater => BinaryOperator::Greater,
930            TokenKind::GreaterEqual => BinaryOperator::GreaterEqual,
931            _ => unreachable!("This function can't be called for other tokens: ({kind})"),
932        }
933    }
934
935    fn eat(&mut self, kind: TokenKind) {
936        self.eat_with_start(kind, self.cur_token.start);
937    }
938
939    fn eat_with_start(&mut self, kind: TokenKind, start: usize) -> bool {
940        if self.at(kind) {
941            self.advance();
942            return true;
943        }
944
945        let val = self.cur_token.value.to_string();
946
947        self.report_expected(
948            start,
949            kind,
950            format!(
951                "{} {}",
952                self.cur_kind(),
953                if self.cur_token.value == TokenValue::None {
954                    ""
955                } else {
956                    &val
957                }
958            ),
959        );
960        unreachable!("Report ends proccess");
961    }
962
963    fn report_expected<T: std::fmt::Display, U: std::fmt::Display>(
964        &self,
965        start: usize,
966        expected: T,
967        got: U,
968    ) {
969        report_error(
970            self.path,
971            self.source,
972            &format!("Expected {expected} but got {got}"),
973            start,
974            self.cur_token.end,
975        );
976    }
977
978    /// Move to the next token
979    fn advance(&mut self) {
980        self.prev_token_end = self.cur_token.end;
981        let token = self.lexer.next_token();
982        self.cur_token = token;
983    }
984
985    fn cur_kind(&self) -> TokenKind {
986        self.cur_token.kind
987    }
988
989    /// Checks if the current index has token `TokenKind`
990    fn at(&self, kind: TokenKind) -> bool {
991        self.cur_kind() == kind
992    }
993}
symboscript_parser/parser/mod.rs

symboscript_parser/parser/
mod.rs
