jetcrab\parser/
core.rs

1use crate::ast::{
2    ArrayLiteral, ArrowFunctionExpression, BinaryExpression, BlockStatement, DebuggerStatement,
3    DoWhileStatement, ExportDeclaration, ExpressionStatement, ForStatement, IfStatement,
4    ImportDeclaration, Node, ObjectLiteral, Position, Program, Property, ReturnStatement, Span,
5    SpreadElement, SwitchCase, SwitchStatement, TemplateElement, TemplateLiteral, WhileStatement,
6    WithStatement,
7};
8use crate::lexer::tokens::Keyword;
9use crate::lexer::{Lexer, Token, TokenKind};
10use crate::parser::error::{ParseResult, ParserError};
11use crate::parser::recovery::{ErrorRecovery, ParsingContext, RecoveryContext, RecoveryStrategy};
12
13pub struct Parser {
14    #[allow(dead_code)]
15    source: String,
16
17    lexer: Lexer,
18
19    pub current: Option<Token>,
20
21    previous: Option<Token>,
22
23    error_recovery: ErrorRecovery,
24
25    context: ParsingContext,
26
27    #[allow(dead_code)]
28    strict_mode: bool,
29}
30
31impl Parser {
32    pub fn new(source: &str) -> Self {
33        let mut lexer = Lexer::new(source);
34        let current = lexer.next_token().ok();
35
36        Self {
37            source: source.to_string(),
38            lexer,
39            current,
40            previous: None,
41            error_recovery: ErrorRecovery::default(),
42            context: ParsingContext::TopLevel,
43            strict_mode: false,
44        }
45    }
46
47    pub fn parse(&mut self) -> ParseResult<Node> {
48        self.parse_program()
49    }
50
51    pub fn parse_with_recovery(&mut self) -> (Option<Node>, Vec<ParserError>) {
52        match self.parse() {
53            Ok(ast) => (Some(ast), self.error_recovery.errors().to_vec()),
54            Err(error) => {
55                self.error_recovery.add_error(error);
56                (None, self.error_recovery.errors().to_vec())
57            }
58        }
59    }
60
61    fn parse_program(&mut self) -> ParseResult<Node> {
62        let mut body = Vec::new();
63        let start_pos = self.current_position();
64
65        if self.is_eof() {
66            let end_pos = self.previous_position();
67            let span = self.create_span(start_pos, end_pos);
68            return Ok(Node::Program(Program {
69                body,
70                source_type: "script".to_string(),
71                span: Some(span),
72            }));
73        }
74
75        while !self.is_eof() {
76            match self.parse_statement() {
77                Ok(stmt) => body.push(stmt),
78                Err(error) => {
79                    if !self.try_recover_from_error(error.clone()) {
80                        return Err(error);
81                    }
82
83                    if self.is_eof() {
84                        break;
85                    }
86                }
87            }
88        }
89
90        let end_pos = self.previous_position();
91        let span = self.create_span(start_pos, end_pos);
92
93        Ok(Node::Program(Program {
94            body,
95            source_type: "script".to_string(),
96            span: Some(span),
97        }))
98    }
99
100    fn parse_statement(&mut self) -> ParseResult<Node> {
101        let old_context = self.context.clone();
102        self.context = ParsingContext::Statement;
103
104        let result = if let Some(token) = &self.current {
105            match &token.kind {
106                TokenKind::Keyword(kw) => match kw.as_str() {
107                    "let" | "const" | "var" => self.parse_declaration(),
108                    "function" => self.parse_function_declaration(),
109                    "class" => self.parse_class_declaration(),
110                    "if" => self.parse_if_statement(),
111                    "while" => self.parse_while_statement(),
112                    "for" => self.parse_for_statement(),
113                    "return" => self.parse_return_statement(),
114                    "break" => self.parse_break_statement(),
115                    "continue" => self.parse_continue_statement(),
116                    "throw" => self.parse_throw_statement(),
117                    "try" => self.parse_try_statement(),
118                    "switch" => self.parse_switch_statement(),
119                    "do" => self.parse_do_while_statement(),
120                    "with" => self.parse_with_statement(),
121                    "debugger" => self.parse_debugger_statement(),
122                    "import" => self.parse_import_declaration(),
123                    "export" => self.parse_export_declaration(),
124                    _ => self.parse_expression_statement(),
125                },
126                TokenKind::LeftBrace => {
127                    // In statement context, { } is always a block statement
128                    // Object literals are parsed in expression context
129                    self.parse_block_statement()
130                }
131                TokenKind::Semicolon => self.parse_empty_statement(),
132                _ => self.parse_expression_statement(),
133            }
134        } else {
135            Err(ParserError::unexpected_end_of_input(None))
136        };
137
138        self.context = old_context;
139        result
140    }
141
142    fn parse_declaration(&mut self) -> ParseResult<Node> {
143        if let Some(token) = &self.current {
144            match &token.kind {
145                TokenKind::Keyword(kw) => match kw.as_str() {
146                    "let" | "const" | "var" => self.parse_variable_declaration(),
147                    "function" => self.parse_function_declaration(),
148                    "class" => self.parse_class_declaration(),
149                    _ => Err(ParserError::invalid_declaration(
150                        "Expected declaration",
151                        self.current_position().unwrap_or_default(),
152                    )),
153                },
154                _ => Err(ParserError::invalid_declaration(
155                    "Expected declaration",
156                    self.current_position().unwrap_or_default(),
157                )),
158            }
159        } else {
160            Err(ParserError::unexpected_end_of_input(None))
161        }
162    }
163
164    fn parse_if_statement(&mut self) -> ParseResult<Node> {
165        self.advance();
166
167        self.expect(TokenKind::LeftParen)?;
168        let test = Box::new(self.parse_expression()?);
169        self.expect(TokenKind::RightParen)?;
170
171        let consequent = Box::new(self.parse_statement()?);
172
173        let alternate = if let Some(token) = &self.current {
174            if let TokenKind::Keyword(kw) = &token.kind {
175                if kw.matches_str("else") {
176                    self.advance();
177                    Some(Box::new(self.parse_statement()?))
178                } else {
179                    None
180                }
181            } else {
182                None
183            }
184        } else {
185            None
186        };
187
188        let span = self.create_span_from_tokens();
189        Ok(Node::IfStatement(IfStatement {
190            test,
191            consequent,
192            alternate,
193            span: Some(span),
194        }))
195    }
196
197    fn parse_while_statement(&mut self) -> ParseResult<Node> {
198        self.advance();
199
200        self.expect(TokenKind::LeftParen)?;
201        let test = Box::new(self.parse_expression()?);
202        self.expect(TokenKind::RightParen)?;
203
204        let body = Box::new(self.parse_statement()?);
205
206        let span = self.create_span_from_tokens();
207        Ok(Node::WhileStatement(WhileStatement {
208            test,
209            body,
210            span: Some(span),
211        }))
212    }
213
214    fn parse_for_statement(&mut self) -> ParseResult<Node> {
215        self.advance(); // consume 'for'
216
217        self.expect(TokenKind::LeftParen)?;
218
219        // Parse init
220        let init = if self.check(TokenKind::Semicolon) {
221            None
222        } else if self.is_declaration() {
223            Some(Box::new(self.parse_variable_declaration_without_semicolon()?))
224        } else {
225            Some(Box::new(self.parse_expression()?))
226        };
227
228        self.expect(TokenKind::Semicolon)?;
229
230        // Parse test
231        let test = if self.check(TokenKind::Semicolon) {
232            None
233        } else {
234            Some(Box::new(self.parse_expression()?))
235        };
236
237        self.expect(TokenKind::Semicolon)?;
238
239        // Parse update
240        let update = if self.check(TokenKind::RightParen) {
241            None
242        } else {
243            Some(Box::new(self.parse_expression()?))
244        };
245
246        self.expect(TokenKind::RightParen)?;
247
248        // Parse body
249        let body = Box::new(self.parse_statement()?);
250
251        let span = self.create_span_from_tokens();
252        Ok(Node::ForStatement(ForStatement {
253            init,
254            test,
255            update,
256            body,
257            span: Some(span),
258        }))
259    }
260
261    fn parse_return_statement(&mut self) -> ParseResult<Node> {
262        self.advance();
263
264        let argument = if !self.check(TokenKind::Semicolon) && !self.is_eof() {
265            Some(Box::new(self.parse_expression()?))
266        } else {
267            None
268        };
269
270        let span = self.create_span_from_tokens();
271        Ok(Node::ReturnStatement(ReturnStatement {
272            argument,
273            span: Some(span),
274        }))
275    }
276
277    fn parse_switch_statement(&mut self) -> ParseResult<Node> {
278        self.advance();
279
280        self.expect(TokenKind::LeftParen)?;
281        let discriminant = Box::new(self.parse_expression()?);
282        self.expect(TokenKind::RightParen)?;
283
284        self.expect(TokenKind::LeftBrace)?;
285
286        let mut cases = Vec::new();
287        while !self.check(TokenKind::RightBrace) && !self.is_eof() {
288            cases.push(self.parse_switch_case()?);
289        }
290
291        self.expect(TokenKind::RightBrace)?;
292
293        let span = self.create_span_from_tokens();
294        Ok(Node::SwitchStatement(SwitchStatement {
295            discriminant,
296            cases,
297            span: Some(span),
298        }))
299    }
300
301    fn parse_switch_case(&mut self) -> ParseResult<SwitchCase> {
302        let test = if let Some(token) = &self.current {
303            if let TokenKind::Keyword(kw) = &token.kind {
304                if kw == "default" {
305                    self.advance();
306                    None
307                } else {
308                    self.advance();
309                    Some(Box::new(self.parse_expression()?))
310                }
311            } else {
312                self.advance();
313                Some(Box::new(self.parse_expression()?))
314            }
315        } else {
316            None
317        };
318
319        self.expect(TokenKind::Colon)?;
320
321        let mut consequent = Vec::new();
322        while !self.check(TokenKind::Keyword(Keyword::Case))
323            && !self.check(TokenKind::Keyword(Keyword::Default))
324            && !self.check(TokenKind::RightBrace)
325            && !self.is_eof()
326        {
327            consequent.push(self.parse_statement()?);
328        }
329
330        let span = self.create_span_from_tokens();
331        Ok(SwitchCase {
332            test,
333            consequent,
334            span: Some(span),
335        })
336    }
337
338    fn parse_do_while_statement(&mut self) -> ParseResult<Node> {
339        self.advance();
340
341        let body = Box::new(self.parse_statement()?);
342
343        if let Some(token) = &self.current {
344            if let TokenKind::Keyword(kw) = &token.kind {
345                if kw == "while" {
346                    self.advance();
347                    self.expect(TokenKind::LeftParen)?;
348                    let test = Box::new(self.parse_expression()?);
349                    self.expect(TokenKind::RightParen)?;
350
351                    let span = self.create_span_from_tokens();
352                    return Ok(Node::DoWhileStatement(DoWhileStatement {
353                        body,
354                        test,
355                        span: Some(span),
356                    }));
357                }
358            }
359        }
360
361        Err(ParserError::invalid_statement(
362            "Expected 'while' after 'do'",
363            self.current_position().unwrap_or_default(),
364        ))
365    }
366
367    fn parse_with_statement(&mut self) -> ParseResult<Node> {
368        self.advance();
369
370        self.expect(TokenKind::LeftParen)?;
371        let object = Box::new(self.parse_expression()?);
372        self.expect(TokenKind::RightParen)?;
373
374        let body = Box::new(self.parse_statement()?);
375
376        let span = self.create_span_from_tokens();
377        Ok(Node::WithStatement(WithStatement {
378            object,
379            body,
380            span: Some(span),
381        }))
382    }
383
384    fn parse_debugger_statement(&mut self) -> ParseResult<Node> {
385        self.advance();
386
387        let span = self.create_span_from_tokens();
388        Ok(Node::DebuggerStatement(DebuggerStatement {
389            span: Some(span),
390        }))
391    }
392
393    pub fn parse_block_statement(&mut self) -> ParseResult<Node> {
394        self.advance();
395
396        let old_context = self.context.clone();
397        self.context = ParsingContext::Block;
398
399        let mut body = Vec::new();
400        while !self.check(TokenKind::RightBrace) && !self.is_eof() {
401            match self.parse_statement() {
402                Ok(stmt) => body.push(stmt),
403                Err(error) => {
404                    if !self.try_recover_from_error(error.clone()) {
405                        self.context = old_context;
406                        return Err(error);
407                    }
408                }
409            }
410        }
411
412        self.expect(TokenKind::RightBrace)?;
413
414        self.context = old_context;
415
416        let span = self.create_span_from_tokens();
417        Ok(Node::BlockStatement(BlockStatement {
418            body,
419            span: Some(span),
420        }))
421    }
422
423    fn parse_empty_statement(&mut self) -> ParseResult<Node> {
424        self.advance();
425
426        let span = self.create_span_from_tokens();
427
428        Ok(Node::ExpressionStatement(ExpressionStatement {
429            expression: Box::new(Node::Null),
430            span: Some(span),
431        }))
432    }
433
434    fn parse_expression_statement(&mut self) -> ParseResult<Node> {
435        let expression = Box::new(self.parse_expression()?);
436
437        if self.check(TokenKind::Semicolon) {
438            self.advance();
439        }
440
441        let span = self.create_span_from_tokens();
442        Ok(Node::ExpressionStatement(ExpressionStatement {
443            expression,
444            span: Some(span),
445        }))
446    }
447
448    fn parse_import_declaration(&mut self) -> ParseResult<Node> {
449        self.advance();
450
451        let span = self.create_span_from_tokens();
452        Ok(Node::ImportDeclaration(ImportDeclaration {
453            specifiers: Vec::new(),
454            source: Box::new(Node::String("".to_string())),
455            span: Some(span),
456        }))
457    }
458
459    fn parse_export_declaration(&mut self) -> ParseResult<Node> {
460        self.advance();
461
462        let span = self.create_span_from_tokens();
463        Ok(Node::ExportDeclaration(ExportDeclaration {
464            declaration: None,
465            specifiers: Vec::new(),
466            source: None,
467            default: false,
468            span: Some(span),
469        }))
470    }
471
472    pub fn parse_expression(&mut self) -> ParseResult<Node> {
473        self.parse_assignment_expression()
474    }
475
476    pub fn parse_equality_expression(&mut self) -> ParseResult<Node> {
477        let mut left = self.parse_relational_expression()?;
478
479        while self.is_equality_operator() {
480            let operator = self.current_token_string();
481            self.advance();
482            let right = Box::new(self.parse_relational_expression()?);
483
484            let span = self.create_span_from_tokens();
485            left = Node::BinaryExpression(BinaryExpression {
486                left: Box::new(left),
487                operator,
488                right,
489                span: Some(span),
490            });
491        }
492
493        Ok(left)
494    }
495
496    pub fn parse_primary_expression(&mut self) -> ParseResult<Node> {
497        if let Some(token) = &self.current {
498            match &token.kind {
499                TokenKind::Number(n) => {
500                    let value = *n;
501                    self.advance();
502                    Ok(Node::Number(value))
503                }
504                TokenKind::String(s) => {
505                    let value = s.clone();
506                    self.advance();
507                    Ok(Node::String(value))
508                }
509                TokenKind::TemplateString(s) => {
510                    let value = s.clone();
511                    self.advance();
512
513                    self.parse_template_literal(value)
514                }
515                TokenKind::Boolean(b) => {
516                    let value = *b;
517                    self.advance();
518                    Ok(Node::Boolean(value))
519                }
520                TokenKind::Null => {
521                    self.advance();
522                    Ok(Node::Null)
523                }
524                TokenKind::Undefined => {
525                    self.advance();
526                    Ok(Node::Undefined)
527                }
528                TokenKind::Keyword(kw) if kw == "this" => {
529                    self.advance();
530                    Ok(Node::This)
531                }
532                TokenKind::LeftParen => {
533                    self.advance();
534                    let expr = self.parse_expression()?;
535                    self.expect(TokenKind::RightParen)?;
536                    Ok(expr)
537                }
538                TokenKind::LeftBracket => self.parse_array_literal(),
539                TokenKind::LeftBrace => self.parse_object_literal(),
540                TokenKind::Keyword(kw) if kw == "function" => self.parse_function_expression(),
541                TokenKind::Keyword(kw) if kw == "class" => self.parse_class_expression(),
542                TokenKind::Keyword(kw) if kw == "new" => self.parse_new_expression(),
543                TokenKind::Keyword(kw) if kw == "async" => {
544                    self.advance();
545                    if self.check(TokenKind::Keyword(Keyword::Function)) {
546                        self.parse_function_expression()
547                    } else {
548                        self.parse_arrow_function_expression(true)
549                    }
550                }
551                _ => {
552                    if self.check_identifier() {
553                        self.parse_identifier()
554                    } else {
555                        Err(ParserError::invalid_expression(
556                            "Unexpected token in expression",
557                            self.current_position().unwrap_or_default(),
558                        ))
559                    }
560                }
561            }
562        } else {
563            Err(ParserError::unexpected_end_of_input(None))
564        }
565    }
566
567    pub fn parse_parameters(&mut self) -> ParseResult<Vec<Node>> {
568        let mut params = Vec::new();
569
570        while !self.check(TokenKind::RightParen) && !self.is_eof() {
571            params.push(self.parse_identifier()?);
572
573            if self.check(TokenKind::Comma) {
574                self.advance();
575            }
576        }
577
578        Ok(params)
579    }
580
581    pub fn parse_arguments(&mut self) -> ParseResult<Vec<Node>> {
582        let mut arguments = Vec::new();
583
584        while !self.check(TokenKind::RightParen) && !self.is_eof() {
585            arguments.push(self.parse_expression()?);
586
587            if self.check(TokenKind::Comma) {
588                self.advance();
589            }
590        }
591
592        Ok(arguments)
593    }
594
595    pub fn parse_function_body(&mut self) -> ParseResult<Node> {
596        self.parse_block_statement()
597    }
598
599    pub fn parse_class_body(&mut self) -> ParseResult<Node> {
600        self.expect(TokenKind::LeftBrace)?;
601
602        let mut body = Vec::new();
603        while !self.check(TokenKind::RightBrace) && !self.is_eof() {
604            body.push(self.parse_statement()?);
605        }
606
607        self.expect(TokenKind::RightBrace)?;
608
609        let span = self.create_span_from_tokens();
610        Ok(Node::BlockStatement(BlockStatement {
611            body,
612            span: Some(span),
613        }))
614    }
615
616    pub fn parse_identifier(&mut self) -> ParseResult<Node> {
617        if let Some(token) = &self.current {
618            if let TokenKind::Identifier(ident) = &token.kind {
619                let name = ident.clone();
620                self.advance();
621                Ok(Node::Identifier(name))
622            } else {
623                Err(ParserError::invalid_syntax(
624                    "Expected identifier",
625                    self.current_position().unwrap_or_default(),
626                ))
627            }
628        } else {
629            Err(ParserError::unexpected_end_of_input(None))
630        }
631    }
632
633    fn current_token(&self) -> Option<&Token> {
634        self.current.as_ref()
635    }
636
637    pub fn current_token_string(&self) -> String {
638        if let Some(token) = &self.current {
639            match &token.kind {
640                TokenKind::Plus => "+".to_string(),
641                TokenKind::Minus => "-".to_string(),
642                TokenKind::Star => "*".to_string(),
643                TokenKind::Slash => "/".to_string(),
644                TokenKind::Percent => "%".to_string(),
645                TokenKind::StarStar => "**".to_string(),
646                TokenKind::Equal => "==".to_string(),
647                TokenKind::NotEqual => "!=".to_string(),
648                TokenKind::StrictEqual => "===".to_string(),
649                TokenKind::StrictNotEqual => "!==".to_string(),
650                TokenKind::LessThan => "<".to_string(),
651                TokenKind::GreaterThan => ">".to_string(),
652                TokenKind::LessThanEqual => "<=".to_string(),
653                TokenKind::GreaterThanEqual => ">=".to_string(),
654                TokenKind::LeftShift => "<<".to_string(),
655                TokenKind::RightShift => ">>".to_string(),
656                TokenKind::UnsignedRightShift => ">>>".to_string(),
657                TokenKind::Assign => "=".to_string(),
658                TokenKind::PlusAssign => "+=".to_string(),
659                TokenKind::MinusAssign => "-=".to_string(),
660                TokenKind::StarAssign => "*=".to_string(),
661                TokenKind::SlashAssign => "/=".to_string(),
662                TokenKind::PercentAssign => "%=".to_string(),
663                TokenKind::StarStarAssign => "**=".to_string(),
664                TokenKind::LeftShiftAssign => "<<=".to_string(),
665                TokenKind::RightShiftAssign => ">>=".to_string(),
666                TokenKind::UnsignedRightShiftAssign => ">>>=".to_string(),
667                TokenKind::BitwiseAndAssign => "&=".to_string(),
668                TokenKind::BitwiseOrAssign => "|=".to_string(),
669                TokenKind::BitwiseXorAssign => "^=".to_string(),
670                TokenKind::LogicalAnd => "&&".to_string(),
671                TokenKind::LogicalOr => "||".to_string(),
672                TokenKind::Exclamation => "!".to_string(),
673                TokenKind::BitwiseAnd => "&".to_string(),
674                TokenKind::BitwiseOr => "|".to_string(),
675                TokenKind::BitwiseXor => "^".to_string(),
676                TokenKind::Tilde => "~".to_string(),
677                TokenKind::Increment => "++".to_string(),
678                TokenKind::Decrement => "--".to_string(),
679                TokenKind::Question => "?".to_string(),
680                TokenKind::Colon => ":".to_string(),
681                TokenKind::Comma => ",".to_string(),
682                TokenKind::Semicolon => ";".to_string(),
683                TokenKind::Dot => ".".to_string(),
684                TokenKind::LeftParen => "(".to_string(),
685                TokenKind::RightParen => ")".to_string(),
686                TokenKind::LeftBracket => "[".to_string(),
687                TokenKind::RightBracket => "]".to_string(),
688                TokenKind::LeftBrace => "{".to_string(),
689                TokenKind::RightBrace => "}".to_string(),
690                TokenKind::Arrow => "=>".to_string(),
691                TokenKind::Spread => "...".to_string(),
692                TokenKind::NullishCoalescing => "??".to_string(),
693                TokenKind::OptionalChaining => "?.".to_string(),
694                TokenKind::Identifier(id) => id.clone(),
695                TokenKind::String(s) => s.clone(),
696                TokenKind::Number(n) => n.to_string(),
697                TokenKind::Keyword(kw) => kw.as_str().to_string(),
698                TokenKind::Boolean(b) => b.to_string(),
699                TokenKind::Eof => "EOF".to_string(),
700                _ => format!("{:?}", token.kind),
701            }
702        } else {
703            "EOF".to_string()
704        }
705    }
706
707    pub fn check(&self, token_kind: TokenKind) -> bool {
708        if let Some(token) = &self.current {
709            std::mem::discriminant(&token.kind) == std::mem::discriminant(&token_kind)
710        } else {
711            false
712        }
713    }
714
715    pub fn check_identifier(&self) -> bool {
716        self.current_token()
717            .map(|t| t.is_identifier())
718            .unwrap_or(false)
719    }
720
721    pub fn expect(&mut self, token_kind: TokenKind) -> ParseResult<()> {
722        if self.check(token_kind.clone()) {
723            self.advance();
724            Ok(())
725        } else {
726            let _current = self
727                .current_token()
728                .map(|t| format!("{:?}", t.kind))
729                .unwrap_or_else(|| "EOF".to_string());
730            Err(ParserError::unexpected_token(
731                self.current_token()
732                    .unwrap_or_else(|| panic!("No current token")),
733                Some(&format!("{token_kind:?}")),
734            ))
735        }
736    }
737
738    pub fn advance(&mut self) {
739        self.previous = self.current.take();
740        self.current = self.lexer.next_token().ok();
741    }
742
743    pub fn is_eof(&self) -> bool {
744        self.current.is_none()
745            || matches!(self.current.as_ref().map(|t| &t.kind), Some(TokenKind::Eof))
746    }
747
748    pub fn current_position(&self) -> Option<Position> {
749        self.current.as_ref().map(|t| Position {
750            line: t.start().line,
751            column: t.start().column,
752        })
753    }
754
755    fn previous_position(&self) -> Option<Position> {
756        self.previous.as_ref().map(|t| Position {
757            line: t.end().line,
758            column: t.end().column,
759        })
760    }
761
762    pub fn create_span_from_tokens(&self) -> Span {
763        let start = self.previous_position().unwrap_or_default();
764        let end = self.current_position().unwrap_or_default();
765        Span::new(start, end)
766    }
767
768    fn create_span(&self, start: Option<Position>, end: Option<Position>) -> Span {
769        let start = start.unwrap_or_default();
770        let end = end.unwrap_or_default();
771        Span::new(start, end)
772    }
773
774    fn is_declaration(&self) -> bool {
775        if let Some(token) = &self.current {
776            matches!(token.kind,
777                TokenKind::Keyword(ref kw) if kw == "let" || kw == "const" || kw == "var" || kw == "function" || kw == "class"
778            )
779        } else {
780            false
781        }
782    }
783
784    pub fn is_assignment_operator(&self) -> bool {
785        if let Some(token) = &self.current {
786            matches!(
787                token.kind,
788                TokenKind::Assign
789                    | TokenKind::PlusAssign
790                    | TokenKind::MinusAssign
791                    | TokenKind::StarAssign
792                    | TokenKind::SlashAssign
793                    | TokenKind::PercentAssign
794                    | TokenKind::StarStarAssign
795                    | TokenKind::LeftShiftAssign
796                    | TokenKind::RightShiftAssign
797                    | TokenKind::UnsignedRightShiftAssign
798                    | TokenKind::BitwiseAndAssign
799                    | TokenKind::BitwiseOrAssign
800                    | TokenKind::BitwiseXorAssign
801            )
802        } else {
803            false
804        }
805    }
806
807    pub fn is_relational_operator(&self) -> bool {
808        if let Some(token) = &self.current {
809            matches!(
810                token.kind,
811                TokenKind::LessThan
812                    | TokenKind::GreaterThan
813                    | TokenKind::LessThanEqual
814                    | TokenKind::GreaterThanEqual
815            ) || matches!(token.kind, TokenKind::Keyword(ref kw) if kw == "instanceof" || kw == "in")
816        } else {
817            false
818        }
819    }
820
821    pub fn is_shift_operator(&self) -> bool {
822        if let Some(token) = &self.current {
823            matches!(
824                token.kind,
825                TokenKind::LeftShift | TokenKind::RightShift | TokenKind::UnsignedRightShift
826            )
827        } else {
828            false
829        }
830    }
831
832    pub fn is_additive_operator(&self) -> bool {
833        if let Some(token) = &self.current {
834            matches!(token.kind, TokenKind::Plus | TokenKind::Minus)
835        } else {
836            false
837        }
838    }
839
840    pub fn is_multiplicative_operator(&self) -> bool {
841        if let Some(token) = &self.current {
842            matches!(
843                token.kind,
844                TokenKind::Star | TokenKind::Slash | TokenKind::Percent
845            )
846        } else {
847            false
848        }
849    }
850
851    pub fn is_exponentiation_operator(&self) -> bool {
852        if let Some(token) = &self.current {
853            matches!(token.kind, TokenKind::StarStar)
854        } else {
855            false
856        }
857    }
858
859    pub fn is_unary_operator(&self) -> bool {
860        if let Some(token) = &self.current {
861            matches!(
862                token.kind,
863                TokenKind::Plus | TokenKind::Minus | TokenKind::Exclamation | TokenKind::Tilde
864            ) || matches!(token.kind, TokenKind::Keyword(ref kw) if kw == "typeof" || kw == "void" || kw == "delete")
865        } else {
866            false
867        }
868    }
869
870    fn try_recover_from_error(&mut self, error: ParserError) -> bool {
871        if !self.error_recovery.can_recover() {
872            return false;
873        }
874
875        self.error_recovery.add_error(error);
876
877        let context = RecoveryContext::new(
878            self.current.clone(),
879            self.previous.clone(),
880            self.context.clone(),
881        );
882
883        let strategy = context.determine_strategy();
884
885        match strategy {
886            RecoveryStrategy::SkipUntil(tokens) => {
887                while !self.is_eof() {
888                    if let Some(token) = self.current_token() {
889                        if tokens
890                            .iter()
891                            .any(|t| format!("{:?}", token.kind).contains(t))
892                        {
893                            break;
894                        }
895                    }
896                    self.advance();
897                }
898                true
899            }
900
901            RecoveryStrategy::SkipUntilStatement => {
902                while !self.is_eof() {
903                    if let Some(token) = self.current_token() {
904                        match token.kind {
905                            TokenKind::Semicolon | TokenKind::RightBrace => break,
906                            _ => self.advance(),
907                        }
908                    } else {
909                        break;
910                    }
911                }
912                true
913            }
914
915            RecoveryStrategy::SkipUntilBlock => {
916                while !self.is_eof() {
917                    if let Some(token) = self.current_token() {
918                        if matches!(token.kind, TokenKind::RightBrace) {
919                            break;
920                        }
921                    }
922                    self.advance();
923                }
924                true
925            }
926
927            RecoveryStrategy::SkipUntilFunction => {
928                while !self.is_eof() {
929                    if let Some(token) = self.current_token() {
930                        match token.kind {
931                            TokenKind::RightBrace | TokenKind::Semicolon => break,
932                            _ => self.advance(),
933                        }
934                    } else {
935                        break;
936                    }
937                }
938                true
939            }
940
941            RecoveryStrategy::SkipUntilClass => {
942                while !self.is_eof() {
943                    if let Some(token) = self.current_token() {
944                        if matches!(token.kind, TokenKind::RightBrace) {
945                            break;
946                        }
947                    }
948                    self.advance();
949                }
950                true
951            }
952
953            RecoveryStrategy::SkipUntilModule => {
954                while !self.is_eof() {
955                    let should_break = if let Some(token) = &self.current {
956                        matches!(token.kind, TokenKind::RightBrace)
957                            || matches!(token.kind, TokenKind::Keyword(ref kw) if kw == "import" || kw == "export")
958                    } else {
959                        false
960                    };
961
962                    if should_break {
963                        break;
964                    }
965                    self.advance();
966                }
967                true
968            }
969
970            RecoveryStrategy::InsertToken(_) => {
971                self.advance();
972                true
973            }
974
975            RecoveryStrategy::ReplaceToken(_) => {
976                self.advance();
977                true
978            }
979
980            RecoveryStrategy::DeleteToken => {
981                self.advance();
982                true
983            }
984
985            RecoveryStrategy::NoRecovery => false,
986        }
987    }
988
989    fn parse_arrow_function_expression(&mut self, is_async: bool) -> ParseResult<Node> {
990        let mut params = Vec::new();
991
992        if self.check(TokenKind::LeftParen) {
993            self.advance();
994            if !self.check(TokenKind::RightParen) {
995                params = self.parse_parameters()?;
996            }
997            self.expect(TokenKind::RightParen)?;
998        } else {
999            params.push(self.parse_identifier()?);
1000        }
1001
1002        self.expect(TokenKind::Arrow)?;
1003
1004        let body = if self.check(TokenKind::LeftBrace) {
1005            Box::new(self.parse_function_body()?)
1006        } else {
1007            Box::new(self.parse_expression()?)
1008        };
1009
1010        let span = self.create_span_from_tokens();
1011        Ok(Node::ArrowFunctionExpression(ArrowFunctionExpression {
1012            params,
1013            body,
1014            expression: !self.check(TokenKind::LeftBrace),
1015            r#async: is_async,
1016            span: Some(span),
1017        }))
1018    }
1019
1020    pub fn parse_destructuring_pattern(&mut self) -> ParseResult<Node> {
1021        if self.check(TokenKind::LeftBrace) {
1022            self.advance();
1023            let mut properties = Vec::new();
1024
1025            while !self.check(TokenKind::RightBrace) && !self.is_eof() {
1026                if self.check_identifier() {
1027                    let key = self.parse_identifier()?;
1028                    let value = if self.check(TokenKind::Colon) {
1029                        self.advance();
1030                        Some(Box::new(self.parse_expression()?))
1031                    } else {
1032                        None
1033                    };
1034
1035                    let span = self.create_span_from_tokens();
1036                    let is_shorthand = value.is_none();
1037                    properties.push(Node::Property(Property {
1038                        key: Box::new(key),
1039                        value: value.unwrap_or_else(|| Box::new(Node::Identifier("".to_string()))),
1040                        kind: "init".to_string(),
1041                        computed: false,
1042                        method: false,
1043                        shorthand: is_shorthand,
1044                        span: Some(span),
1045                    }));
1046                } else if self.check(TokenKind::Spread) {
1047                    self.advance();
1048                    let argument = Box::new(self.parse_expression()?);
1049                    let span = self.create_span_from_tokens();
1050                    properties.push(Node::SpreadElement(SpreadElement {
1051                        argument,
1052                        span: Some(span),
1053                    }));
1054                }
1055
1056                if self.check(TokenKind::Comma) {
1057                    self.advance();
1058                } else {
1059                    break;
1060                }
1061            }
1062
1063            self.expect(TokenKind::RightBrace)?;
1064
1065            let span = self.create_span_from_tokens();
1066            Ok(Node::ObjectLiteral(ObjectLiteral {
1067                properties,
1068                span: Some(span),
1069            }))
1070        } else if self.check(TokenKind::LeftBracket) {
1071            self.advance();
1072            let mut elements = Vec::new();
1073
1074            while !self.check(TokenKind::RightBracket) && !self.is_eof() {
1075                if self.check(TokenKind::Comma) {
1076                    elements.push(None);
1077                    self.advance();
1078                } else if self.check(TokenKind::Spread) {
1079                    self.advance();
1080                    let argument = Box::new(self.parse_expression()?);
1081                    let span = self.create_span_from_tokens();
1082                    elements.push(Some(Node::SpreadElement(SpreadElement {
1083                        argument,
1084                        span: Some(span),
1085                    })));
1086                } else {
1087                    elements.push(Some(self.parse_expression()?));
1088                }
1089
1090                if self.check(TokenKind::Comma) {
1091                    self.advance();
1092                } else {
1093                    break;
1094                }
1095            }
1096
1097            self.expect(TokenKind::RightBracket)?;
1098
1099            let span = self.create_span_from_tokens();
1100            Ok(Node::ArrayLiteral(ArrayLiteral {
1101                elements,
1102                span: Some(span),
1103            }))
1104        } else {
1105            self.parse_identifier()
1106        }
1107    }
1108
1109    fn parse_template_literal(&mut self, initial_value: String) -> ParseResult<Node> {
1110        let mut quasis = Vec::new();
1111        let mut expressions = Vec::new();
1112
1113        quasis.push(TemplateElement {
1114            value: initial_value,
1115            tail: false,
1116            span: None,
1117        });
1118
1119        while !self.check(TokenKind::TemplateEnd) && !self.is_eof() {
1120            if self.check(TokenKind::TemplateExpr) {
1121                self.advance();
1122                let expr = self.parse_expression()?;
1123                expressions.push(expr);
1124
1125                if self.check(TokenKind::RightBrace) {
1126                    self.advance();
1127                } else {
1128                    return Err(ParserError::unexpected_token(
1129                        self.current_token().unwrap(),
1130                        Some("Expected '}' in template expression"),
1131                    ));
1132                }
1133            } else if let TokenKind::TemplateString(value) = &self.current_token().unwrap().kind {
1134                let value = value.clone();
1135                self.advance();
1136                quasis.push(TemplateElement {
1137                    value,
1138                    tail: false,
1139                    span: None,
1140                });
1141            } else {
1142                break;
1143            }
1144        }
1145
1146        if self.check(TokenKind::TemplateEnd) {
1147            self.advance();
1148
1149            if let Some(last_quasi) = quasis.last_mut() {
1150                last_quasi.tail = true;
1151            }
1152        }
1153
1154        let span = self.create_span_from_tokens();
1155        Ok(Node::TemplateLiteral(TemplateLiteral {
1156            quasis,
1157            expressions,
1158            span: Some(span),
1159        }))
1160    }
1161}
jetcrab\parser/core.rs

jetcrab\parser/
core.rs
