lucia_lang/compiler/
parser.rs

1//! The parser.
2
3use thiserror::Error;
4
5use crate::utils::Join;
6
7use super::{
8    ast::*,
9    lexer::LexerError,
10    token::{LiteralKind, Token, TokenKind, TokenType},
11};
12
13macro_rules! unexpected_token_error {
14    ($self:expr) => {
15        return Err(ParserError::UnexpectedToken {
16            token: Box::new($self.token.clone()),
17            expected: $self.expected_tokens.clone(),
18        })
19    };
20}
21
22/// The parser. Turns token iter into AST.
23pub struct Parser<'a> {
24    /// The current token.
25    pub token: Token,
26    /// The previous token.
27    pub prev_token: Token,
28    /// The token iter.
29    pub token_iter: &'a mut dyn Iterator<Item = Token>,
30    /// Is token iter end.
31    pub is_eof: bool,
32
33    expected_tokens: Vec<TokenType>,
34}
35
36impl<'a> Parser<'a> {
37    /// Constructs a new `Parser` with a token iter.
38    pub fn new(token_iter: &'a mut dyn Iterator<Item = Token>) -> Self {
39        let mut parser = Parser {
40            token: Token::dummy(),
41            prev_token: Token::dummy(),
42            token_iter,
43            is_eof: false,
44            expected_tokens: Vec::new(),
45        };
46        parser.bump();
47        parser
48    }
49
50    /// Moves to the next token.
51    fn bump(&mut self) {
52        self.prev_token = self.token.clone();
53        self.token = self.token_iter.next().unwrap_or_else(|| {
54            self.is_eof = true;
55            Token::dummy()
56        });
57        self.expected_tokens.clear();
58    }
59
60    /// Eats EOL.
61    fn eat_eol(&mut self) {
62        while self.token.kind == TokenKind::EOL {
63            self.bump();
64        }
65    }
66
67    /// Expects and consumes the token `t`. Signals an error if the next token is not `t`.
68    fn expect(&mut self, t: &TokenKind) -> Result<(), ParserError> {
69        if self.token.kind == *t {
70            self.bump();
71            Ok(())
72        } else if self.is_eof {
73            Err(ParserError::UnexpectedEOF)
74        } else {
75            self.expected_tokens.push(TokenType::Token(t.clone()));
76            unexpected_token_error!(self)
77        }
78    }
79
80    /// Checks if the current token is `t`, and returns `true` if so.
81    /// This method will automatically add `t` to `expected_tokens` if `t` is not encountered.
82    fn check(&mut self, t: &TokenKind) -> bool {
83        let is_present = self.token.kind == *t;
84        if !is_present {
85            self.expected_tokens.push(TokenType::Token(t.clone()));
86        }
87        is_present
88    }
89
90    fn check_noexpect(&self, t: &TokenKind) -> bool {
91        self.token.kind == *t
92    }
93
94    /// Consumes a token 't' if it exists. Returns whether the given token was present.
95    fn eat(&mut self, t: &TokenKind) -> bool {
96        let is_present = self.check(t);
97        if is_present {
98            self.bump()
99        }
100        is_present
101    }
102
103    fn eat_noexpect(&mut self, t: &TokenKind) -> bool {
104        let is_present = self.check_noexpect(t);
105        if is_present {
106            self.bump()
107        }
108        is_present
109    }
110
111    fn eat_ident(&mut self) -> Option<String> {
112        if let TokenKind::Ident(v) = self.token.kind.clone() {
113            self.bump();
114            Some(v)
115        } else {
116            self.expected_tokens.push(TokenType::Literal);
117            None
118        }
119    }
120
121    fn eat_literal(&mut self) -> Option<LiteralKind> {
122        if let TokenKind::Literal(v) = self.token.kind.clone() {
123            self.bump();
124            Some(v)
125        } else {
126            self.expected_tokens.push(TokenType::Literal);
127            None
128        }
129    }
130
131    /// Parse token iter into AST (`Box<Block>`).
132    pub fn parse(&mut self) -> Result<Box<Block>, ParserError> {
133        Ok(Box::new(Block {
134            start: self.token.start,
135            body: {
136                let mut temp = Vec::new();
137                while !self.is_eof {
138                    temp.push(self.parse_stmt()?);
139                    if self.is_eof {
140                        break;
141                    }
142                    self.expect(&TokenKind::EOL)?;
143                    self.eat_eol();
144                }
145                temp
146            },
147            end: self.prev_token.end,
148        }))
149    }
150
151    /// Parse statement.
152    fn parse_stmt(&mut self) -> Result<Stmt, ParserError> {
153        macro_rules! stmt {
154            ($kind:expr) => {
155                Stmt {
156                    start: self.prev_token.start,
157                    kind: $kind,
158                    end: self.prev_token.end,
159                }
160            };
161        }
162        macro_rules! check_assign_left {
163            ($ast_node:expr) => {
164                match $ast_node.kind {
165                    ExprKind::Ident(_) => (),
166                    ExprKind::Member { safe, .. } | ExprKind::MetaMember { safe, .. } => {
167                        if safe {
168                            return Err(ParserError::ParseAssignStmtError);
169                        }
170                    }
171                    _ => return Err(ParserError::ParseAssignStmtError),
172                }
173            };
174        }
175        macro_rules! assign_op_stmt {
176            ($ast_node:expr, $bin_op:expr) => {{
177                check_assign_left!($ast_node);
178                let right = self.parse_expr(1)?;
179                Stmt {
180                    start: $ast_node.start,
181                    end: right.end,
182                    kind: StmtKind::AssignOp {
183                        operator: $bin_op,
184                        left: $ast_node,
185                        right,
186                    },
187                }
188            }};
189        }
190        self.eat_eol();
191        let ast_node = if self.eat(&TokenKind::If) {
192            self.parse_stmt_if()?
193        } else if self.eat(&TokenKind::Loop) {
194            stmt!(StmtKind::Loop {
195                body: self.parse_block()?,
196            })
197        } else if self.eat(&TokenKind::While) {
198            stmt!(StmtKind::While {
199                test: self.parse_expr(1)?,
200                body: self.parse_block()?,
201            })
202        } else if self.eat(&TokenKind::For) {
203            stmt!(StmtKind::For {
204                left: {
205                    let mut temp = Vec::new();
206                    while !self.eat_noexpect(&TokenKind::In) {
207                        temp.push(self.parse_ident()?);
208                        if self.eat(&TokenKind::In) {
209                            break;
210                        }
211                        self.expect(&TokenKind::Comma)?;
212                    }
213                    temp
214                },
215                right: self.parse_expr(1)?,
216                body: self.parse_block()?,
217            })
218        } else if self.eat(&TokenKind::Break) {
219            stmt!(StmtKind::Break)
220        } else if self.eat(&TokenKind::Continue) {
221            stmt!(StmtKind::Continue)
222        } else if self.eat(&TokenKind::Return) {
223            stmt!(StmtKind::Return {
224                argument: self.parse_expr(1)?,
225            })
226        } else if self.eat(&TokenKind::Throw) {
227            stmt!(StmtKind::Throw {
228                argument: self.parse_expr(1)?,
229            })
230        } else if self.eat(&TokenKind::Global) {
231            stmt!(StmtKind::Global {
232                arguments: {
233                    let mut temp = Vec::new();
234                    while !self.check_noexpect(&TokenKind::EOL) {
235                        temp.push(self.parse_ident()?);
236                        if self.check(&TokenKind::EOL) {
237                            break;
238                        }
239                        self.expect(&TokenKind::Comma)?;
240                    }
241                    temp
242                },
243            })
244        } else if self.eat(&TokenKind::Import) {
245            stmt!({
246                let mut path = Vec::new();
247                let mut glob = false;
248                loop {
249                    if self.check_noexpect(&TokenKind::EOL)
250                        | self.check_noexpect(&TokenKind::As)
251                        | self.check_noexpect(&TokenKind::OpenBrace)
252                    {
253                        break;
254                    } else if self.eat_noexpect(&TokenKind::Mul) {
255                        glob = true;
256                        break;
257                    }
258                    path.push(self.parse_ident()?);
259                    if self.check(&TokenKind::EOL)
260                        | self.check(&TokenKind::As)
261                        | self.check(&TokenKind::OpenBrace)
262                    {
263                        break;
264                    }
265                    self.expect(&TokenKind::DoubleColon)?;
266                }
267                if path.is_empty() {
268                    self.expected_tokens = vec![TokenType::Ident];
269                    unexpected_token_error!(self);
270                }
271                let kind = if glob {
272                    ImportKind::Glob
273                } else if self.check(&TokenKind::EOL) {
274                    ImportKind::Simple(Box::new(path.last().unwrap().clone()))
275                } else if self.eat(&TokenKind::As) {
276                    ImportKind::Simple(Box::new(self.parse_ident()?))
277                } else if self.eat(&TokenKind::OpenBrace) {
278                    let mut temp = Vec::new();
279                    while !self.eat_noexpect(&TokenKind::CloseBrace) {
280                        let t = self.parse_ident()?;
281                        if self.eat(&TokenKind::As) {
282                            temp.push((t, self.parse_ident()?));
283                        } else {
284                            temp.push((t.clone(), t));
285                        }
286                        self.eat_eol();
287                        if self.eat(&TokenKind::CloseBrace) {
288                            break;
289                        }
290                        self.expect(&TokenKind::Comma)?;
291                        self.eat_eol();
292                    }
293                    ImportKind::Nested(temp)
294                } else {
295                    unexpected_token_error!(self);
296                };
297                StmtKind::Import { path, kind }
298            })
299        } else if self.check(&TokenKind::OpenBrace) {
300            (*self.parse_block()?).into()
301        } else if self.eat(&TokenKind::Fn) {
302            stmt!(StmtKind::Assign {
303                left: Box::new(self.parse_ident()?.into()),
304                right: self.parse_expr_func(false)?
305            })
306        } else {
307            let ast_node = self.parse_expr(1)?;
308            if self.check(&TokenKind::Comma) {
309                check_assign_left!(ast_node);
310                let start = ast_node.start;
311                let mut left = vec![*ast_node];
312                loop {
313                    if self.eat(&TokenKind::Comma) {
314                        let ast_node = self.parse_expr(1)?;
315                        check_assign_left!(ast_node);
316                        left.push(*ast_node);
317                    } else {
318                        self.expect(&TokenKind::Assign)?;
319                        break;
320                    }
321                }
322                let right = self.parse_expr(1)?;
323                if self.check_noexpect(&TokenKind::Comma) {
324                    let mut right = vec![*right];
325                    loop {
326                        if self.eat(&TokenKind::Comma) {
327                            right.push(*self.parse_expr(1)?);
328                        } else {
329                            break;
330                        }
331                    }
332                    if left.len() != right.len() {
333                        return Err(ParserError::ParseAssignStmtError);
334                    }
335                    Stmt {
336                        start,
337                        end: self.prev_token.end,
338                        kind: StmtKind::AssignMulti { left, right },
339                    }
340                } else {
341                    Stmt {
342                        start,
343                        end: right.end,
344                        kind: StmtKind::AssignUnpack { left, right },
345                    }
346                }
347            } else if self.eat(&TokenKind::Assign) {
348                check_assign_left!(ast_node);
349                let right = self.parse_expr(1)?;
350                Stmt {
351                    start: ast_node.start,
352                    end: right.end,
353                    kind: StmtKind::Assign {
354                        left: ast_node,
355                        right,
356                    },
357                }
358            } else if self.eat(&TokenKind::AddAssign) {
359                assign_op_stmt!(ast_node, BinOp::Add)
360            } else if self.eat(&TokenKind::SubAssign) {
361                assign_op_stmt!(ast_node, BinOp::Sub)
362            } else if self.eat(&TokenKind::MulAssign) {
363                assign_op_stmt!(ast_node, BinOp::Mul)
364            } else if self.eat(&TokenKind::DivAssign) {
365                assign_op_stmt!(ast_node, BinOp::Div)
366            } else if self.eat(&TokenKind::ModAssign) {
367                assign_op_stmt!(ast_node, BinOp::Mod)
368            } else {
369                Stmt {
370                    start: ast_node.start,
371                    end: ast_node.end,
372                    kind: StmtKind::Expr(ast_node),
373                }
374            }
375        };
376        Ok(ast_node)
377    }
378
379    /// Parse block.
380    fn parse_block(&mut self) -> Result<Box<Block>, ParserError> {
381        self.expect(&TokenKind::OpenBrace)?;
382        self.eat_eol();
383        Ok(Box::new(Block {
384            start: self.prev_token.start,
385            body: {
386                let mut temp = Vec::new();
387                while !self.eat_noexpect(&TokenKind::CloseBrace) {
388                    temp.push(self.parse_stmt()?);
389                    if self.eat(&TokenKind::CloseBrace) {
390                        break;
391                    }
392                    self.expect(&TokenKind::EOL)?;
393                    self.eat_eol();
394                }
395                temp
396            },
397            end: self.prev_token.end,
398        }))
399    }
400
401    /// Parse if statement.
402    fn parse_stmt_if(&mut self) -> Result<Stmt, ParserError> {
403        Ok(Stmt {
404            start: self.prev_token.start,
405            kind: StmtKind::If {
406                test: self.parse_expr(1)?,
407                consequent: self.parse_block()?,
408                alternate: {
409                    if self.eat(&TokenKind::Else) {
410                        Some(Box::new(if self.eat(&TokenKind::If) {
411                            self.parse_stmt_if()?
412                        } else {
413                            (*self.parse_block()?).into()
414                        }))
415                    } else {
416                        None
417                    }
418                },
419            },
420            end: self.prev_token.end,
421        })
422    }
423
424    /// Parse expression.
425    fn parse_expr(&mut self, min_precedence: u32) -> Result<Box<Expr>, ParserError> {
426        let start = self.token.start;
427        let mut left = self.parse_expr_unary()?;
428        loop {
429            let operator = match self.token.kind {
430                TokenKind::Is => BinOp::Is,
431                TokenKind::And => BinOp::And,
432                TokenKind::Or => BinOp::Or,
433                TokenKind::Eq => BinOp::Eq,
434                TokenKind::NotEq => BinOp::Ne,
435                TokenKind::LtEq => BinOp::Le,
436                TokenKind::GtEq => BinOp::Ge,
437                TokenKind::Lt => BinOp::Lt,
438                TokenKind::Gt => BinOp::Gt,
439                TokenKind::Add => BinOp::Add,
440                TokenKind::Sub => BinOp::Sub,
441                TokenKind::Mul => BinOp::Mul,
442                TokenKind::Div => BinOp::Div,
443                TokenKind::Mod => BinOp::Mod,
444                _ => break,
445            };
446            if operator.precedence() < min_precedence {
447                break;
448            }
449            self.bump();
450            let right = self.parse_expr(operator.precedence() + 1)?;
451            left = Box::new(Expr {
452                kind: ExprKind::Binary {
453                    operator,
454                    left,
455                    right,
456                },
457                start,
458                end: self.prev_token.end,
459            })
460        }
461        Ok(left)
462    }
463
464    /// Parse unary expression.
465    fn parse_expr_unary(&mut self) -> Result<Box<Expr>, ParserError> {
466        macro_rules! unary_expr {
467            ($un_op:expr) => {{
468                Ok(Box::new(Expr {
469                    start: self.token.start,
470                    kind: ExprKind::Unary {
471                        operator: $un_op,
472                        argument: self.parse_expr_primary()?,
473                    },
474                    end: self.prev_token.end,
475                }))
476            }};
477        }
478        if self.eat_noexpect(&TokenKind::Not) {
479            unary_expr!(UnOp::Not)
480        } else if self.eat_noexpect(&TokenKind::Sub) {
481            unary_expr!(UnOp::Neg)
482        } else {
483            self.parse_expr_primary()
484        }
485    }
486
487    /// Parse primary expression.
488    fn parse_expr_primary(&mut self) -> Result<Box<Expr>, ParserError> {
489        let start = self.token.start;
490        let mut ast_node = self.parse_expr_atom()?;
491        macro_rules! member_attr_expr {
492            ($member_expr_kind:expr, $safe:expr) => {
493                if self.eat_noexpect(&TokenKind::Pound) {
494                    Box::new(Expr {
495                        kind: ExprKind::MetaMember {
496                            table: ast_node,
497                            safe: $safe,
498                        },
499                        start,
500                        end: self.prev_token.end,
501                    })
502                } else {
503                    Box::new(Expr {
504                        kind: ExprKind::Member {
505                            table: ast_node,
506                            kind: $member_expr_kind,
507                            safe: $safe,
508                            property: Box::new(self.parse_ident()?.into()),
509                        },
510                        start,
511                        end: self.prev_token.end,
512                    })
513                }
514            };
515        }
516        macro_rules! member_item_expr {
517            ($safe:expr) => {
518                if self.eat_noexpect(&TokenKind::Pound) {
519                    Box::new(Expr {
520                        kind: ExprKind::MetaMember {
521                            table: ast_node,
522                            safe: $safe,
523                        },
524                        start: {
525                            self.expect(&TokenKind::CloseBracket)?;
526                            start
527                        },
528                        end: self.prev_token.end,
529                    })
530                } else {
531                    Box::new(Expr {
532                        kind: ExprKind::Member {
533                            table: ast_node,
534                            kind: MemberKind::Bracket,
535                            safe: $safe,
536                            property: self.parse_expr(1)?,
537                        },
538                        start: {
539                            self.expect(&TokenKind::CloseBracket)?;
540                            start
541                        },
542                        end: self.prev_token.end,
543                    })
544                }
545            };
546        }
547        loop {
548            ast_node = if self.eat_noexpect(&TokenKind::OpenParen) {
549                Box::new(Expr {
550                    kind: ExprKind::Call {
551                        callee: ast_node,
552                        arguments: {
553                            let mut temp = Vec::new();
554                            while !self.eat_noexpect(&TokenKind::CloseParen) {
555                                temp.push(*self.parse_expr(1)?);
556                                self.eat_eol();
557                                if self.eat(&TokenKind::CloseParen) {
558                                    break;
559                                }
560                                self.expect(&TokenKind::Comma)?;
561                                self.eat_eol();
562                            }
563                            temp
564                        },
565                        propagating_error: false,
566                    },
567                    start,
568                    end: self.prev_token.end,
569                })
570            } else if self.eat_noexpect(&TokenKind::OpenBracket) {
571                member_item_expr!(false)
572            } else if self.eat_noexpect(&TokenKind::Dot) {
573                member_attr_expr!(MemberKind::Dot, false)
574            } else if self.eat_noexpect(&TokenKind::DoubleColon) {
575                member_attr_expr!(MemberKind::DoubleColon, false)
576            } else if self.eat_noexpect(&TokenKind::Question) {
577                if self.eat(&TokenKind::OpenBracket) {
578                    member_item_expr!(true)
579                } else if self.eat(&TokenKind::Dot) {
580                    member_attr_expr!(MemberKind::Dot, true)
581                } else if self.eat(&TokenKind::DoubleColon) {
582                    member_attr_expr!(MemberKind::DoubleColon, true)
583                } else {
584                    unexpected_token_error!(self);
585                }
586            } else {
587                break;
588            };
589        }
590        Ok(ast_node)
591    }
592
593    /// Parse atom expression.
594    fn parse_expr_atom(&mut self) -> Result<Box<Expr>, ParserError> {
595        macro_rules! lit_expr {
596            ($lit_kind:expr) => {{
597                Ok(Box::new(Expr::from(Lit {
598                    value: $lit_kind,
599                    start: self.token.start,
600                    end: self.token.end,
601                })))
602            }};
603        }
604        if self.eat(&TokenKind::OpenParen) {
605            let temp = self.parse_expr(1)?;
606            self.expect(&TokenKind::CloseParen)?;
607            Ok(temp)
608        } else if self.eat(&TokenKind::Null) {
609            lit_expr!(LitKind::Null)
610        } else if self.eat(&TokenKind::True) {
611            lit_expr!(LitKind::Bool(true))
612        } else if self.eat(&TokenKind::False) {
613            lit_expr!(LitKind::Bool(false))
614        } else if let Some(v) = self.eat_literal() {
615            lit_expr!(match v {
616                LiteralKind::Int(v) => LitKind::Int(v?),
617                LiteralKind::Float(v) => LitKind::Float(v?),
618                LiteralKind::Str(v) => LitKind::Str(v?),
619            })
620        } else if self.eat(&TokenKind::OpenBrace) {
621            self.parse_expr_table()
622        } else if self.eat(&TokenKind::OpenBracket) {
623            self.parse_expr_list()
624        } else if self.eat(&TokenKind::Fn) {
625            self.parse_expr_func(false)
626        } else if self.eat(&TokenKind::VBar) {
627            self.parse_expr_func(true)
628        } else if self.eat(&TokenKind::Do) {
629            Ok(Box::new(Expr {
630                start: self.prev_token.start,
631                kind: ExprKind::Function {
632                    kind: FunctionKind::Do,
633                    params: Vec::new(),
634                    variadic: None,
635                    body: self.parse_block()?,
636                },
637                end: self.prev_token.end,
638            }))
639        } else if self.eat(&TokenKind::Try) {
640            let mut temp = self.parse_expr_primary()?;
641            if let ExprKind::Call {
642                propagating_error, ..
643            } = &mut temp.kind
644            {
645                *propagating_error = true;
646            } else {
647                return Err(ParserError::ParseTryExprError);
648            }
649            Ok(temp)
650        } else {
651            Ok(Box::new(self.parse_ident()?.into()))
652        }
653    }
654
655    /// Parse table expression.
656    fn parse_expr_table(&mut self) -> Result<Box<Expr>, ParserError> {
657        Ok(Box::new(Expr {
658            start: self.prev_token.start,
659            kind: ExprKind::Table {
660                properties: {
661                    let mut temp = Vec::new();
662                    self.eat_eol();
663                    while !self.eat_noexpect(&TokenKind::CloseBrace) {
664                        let start = self.token.start;
665                        let key = self.parse_expr(1)?;
666                        self.expect(&TokenKind::Colon)?;
667                        let value = self.parse_expr(1)?;
668                        temp.push(TableProperty {
669                            key,
670                            value,
671                            start,
672                            end: self.prev_token.end,
673                        });
674                        self.eat_eol();
675                        if self.eat(&TokenKind::CloseBrace) {
676                            break;
677                        }
678                        self.expect(&TokenKind::Comma)?;
679                        self.eat_eol();
680                    }
681                    temp
682                },
683            },
684            end: self.prev_token.end,
685        }))
686    }
687
688    /// Parse table expression.
689    fn parse_expr_list(&mut self) -> Result<Box<Expr>, ParserError> {
690        Ok(Box::new(Expr {
691            start: self.prev_token.start,
692            kind: ExprKind::List {
693                items: {
694                    let mut temp = Vec::new();
695                    self.eat_eol();
696                    while !self.eat_noexpect(&TokenKind::CloseBracket) {
697                        temp.push(*self.parse_expr(1)?);
698                        self.eat_eol();
699                        if self.eat(&TokenKind::CloseBracket) {
700                            break;
701                        }
702                        self.expect(&TokenKind::Comma)?;
703                        self.eat_eol();
704                    }
705                    temp
706                },
707            },
708            end: self.prev_token.end,
709        }))
710    }
711
712    /// Parse function expression.
713    fn parse_expr_func(&mut self, is_closure: bool) -> Result<Box<Expr>, ParserError> {
714        let start = self.prev_token.start;
715        let end_token = if is_closure {
716            TokenKind::VBar
717        } else {
718            self.expect(&TokenKind::OpenParen)?;
719            TokenKind::CloseParen
720        };
721        let mut variadic = None;
722        Ok(Box::new(Expr {
723            start,
724            kind: ExprKind::Function {
725                kind: if is_closure {
726                    FunctionKind::Closure
727                } else {
728                    FunctionKind::Function
729                },
730                params: {
731                    let mut temp = Vec::new();
732                    while !self.eat_noexpect(&end_token) {
733                        if self.eat_noexpect(&TokenKind::Mul) {
734                            variadic = Some(Box::new(self.parse_ident()?));
735                            self.expect(&end_token)?;
736                            break;
737                        }
738                        temp.push(self.parse_ident()?);
739                        self.eat_eol();
740                        if self.eat(&end_token) {
741                            break;
742                        }
743                        self.expect(&TokenKind::Comma)?;
744                        self.eat_eol();
745                    }
746                    temp
747                },
748                variadic,
749                body: self.parse_block()?,
750            },
751            end: self.prev_token.end,
752        }))
753    }
754
755    /// Parse ident.
756    fn parse_ident(&mut self) -> Result<Ident, ParserError> {
757        if let Some(v) = self.eat_ident() {
758            Ok(Ident {
759                start: self.token.start,
760                name: v,
761                end: self.token.end,
762            })
763        } else {
764            unexpected_token_error!(self)
765        }
766    }
767}
768
769/// Kind of ParserError.
770#[derive(Error, Debug, Clone, PartialEq)]
771pub enum ParserError {
772    #[error("unexpected token (expected {}, found {token})", .expected.iter().join(", "))]
773    UnexpectedToken {
774        token: Box<Token>,
775        expected: Vec<TokenType>,
776    },
777    #[error("unexpected EOF")]
778    UnexpectedEOF,
779    #[error("parse assign statement error")]
780    ParseAssignStmtError,
781    #[error("parse try expression error")]
782    ParseTryExprError,
783    #[error(transparent)]
784    LexerError(#[from] LexerError),
785}
lucia_lang/compiler/parser.rs

lucia_lang/compiler/
parser.rs
