1use super::ast::*;
2use crate::compiler::lexer::{Lexer, Token, TokenType};
3
4pub struct Parser {
5 pub lexer: Lexer,
6 current: Option<Token>,
7 peek_token: Option<Token>,
8
9 saved_pos: usize,
10 saved_line: u32,
11 saved_col: u32,
12 allow_in: bool,
13}
14
15impl Parser {
16 pub fn new(source: &str) -> Self {
17 let mut lexer = Lexer::new(source);
18 let current = lexer.next_token();
19 let saved_pos = lexer.pos;
20 let saved_line = lexer.line;
21 let saved_col = lexer.column;
22 let peek_token = lexer.next_token();
23 Parser {
24 lexer,
25 current,
26 peek_token,
27 saved_pos,
28 saved_line,
29 saved_col,
30 allow_in: true,
31 }
32 }
33
34 fn advance(&mut self) -> Option<Token> {
35 let cur = self.current.take();
36 if let Some(ref t) = cur {
37 self.saved_line = t.line;
38 self.saved_col = t.column;
39 }
40 self.current = self.peek_token.take();
41 self.saved_pos = self.lexer.pos;
42 self.peek_token = self.lexer.next_token();
43 cur
44 }
45
46 fn expect(&mut self, value: &str) -> Result<Token, String> {
47 match &self.current {
48 Some(t) if t.value == value => {
49 let tok = t.clone();
50 self.advance();
51 Ok(tok)
52 }
53 Some(t) => Err(self.error(&format!(
54 "Expected '{}', but got '{}' at pos {}",
55 value,
56 t.value,
57 self.lexer.pos()
58 ))),
59 None => Err(self.error(&format!("Expected '{}', but got EOF", value))),
60 }
61 }
62
63 fn expect_semicolon(&mut self) -> Result<(), String> {
64 if let Some(ref t) = self.current {
65 if t.value == ";" {
66 self.advance();
67 }
68 }
69 Ok(())
70 }
71
72 fn at(&self, value: &str) -> bool {
73 self.current.as_ref().map_or(false, |t| t.value == value)
74 }
75
76 fn at_keyword(&self, kw: &str) -> bool {
77 self.current.as_ref().map_or(false, |t| {
78 t.token_type == TokenType::Keyword && t.value == kw
79 })
80 }
81
82 fn at_punct(&self, p: &str) -> bool {
83 self.current.as_ref().map_or(false, |t| {
84 t.token_type == TokenType::Punctuator && t.value == p
85 })
86 }
87
88 fn at_template_start(&self) -> bool {
89 self.current.as_ref().map_or(false, |t| {
90 matches!(
91 t.token_type,
92 TokenType::NoSubstitutionTemplate | TokenType::TemplateHead
93 )
94 })
95 }
96
97 fn peek_at(&self, value: &str) -> bool {
98 self.peek_token.as_ref().map_or(false, |t| t.value == value)
99 }
100
101 fn peek_value(&self) -> Option<&str> {
102 self.peek_token.as_ref().map(|t| t.value.as_str())
103 }
104
105 fn cur_value(&self) -> &str {
106 self.current
107 .as_ref()
108 .map(|t| t.value.as_str())
109 .unwrap_or("")
110 }
111
112 fn cur_type(&self) -> Option<TokenType> {
113 self.current.as_ref().map(|t| t.token_type)
114 }
115
116 fn is_eof(&self) -> bool {
117 self.current.is_none()
118 }
119
120 fn error(&self, msg: &str) -> String {
121 let line = self.current.as_ref().map(|t| t.line).unwrap_or(0);
122 let col = self.current.as_ref().map(|t| t.column).unwrap_or(0);
123 format!("Parse error ({}:{}): {}", line, col, msg)
124 }
125}
126
127impl Parser {
128 pub fn parse(&mut self) -> Result<Program, String> {
129 if let Some(ref t) = self.current {
130 if t.token_type == TokenType::Hashbang {
131 self.advance();
132 }
133 }
134
135 let mut body = Vec::new();
136 let mut lines = Vec::new();
137 while !self.is_eof() {
138 let line = self.current.as_ref().map(|t| t.line).unwrap_or(0);
139 body.push(self.parse_statement_list_item()?);
140 lines.push(line);
141 }
142
143 Ok(Program {
144 body,
145 lines,
146 source_type: SourceType::Script,
147 })
148 }
149
150 fn parse_statement_list_item(&mut self) -> Result<ASTNode, String> {
151 if self.at_keyword("import") && !self.peek_at("(") {
152 return self
153 .parse_import_declaration()
154 .map(ASTNode::ImportDeclaration);
155 }
156 if self.at_keyword("export") {
157 return self.parse_export_declaration();
158 }
159 self.parse_statement()
160 }
161
162 fn parse_statement(&mut self) -> Result<ASTNode, String> {
163 if self.is_eof() {
164 return Ok(ASTNode::EmptyStatement);
165 }
166
167 let tok = self.current.clone();
168
169 match tok.as_ref().map(|t| (t.token_type, t.value.as_str())) {
170 Some((TokenType::Punctuator, "{")) => self.parse_block_statement(),
171 Some((TokenType::Punctuator, ";")) => {
172 self.advance();
173 Ok(ASTNode::EmptyStatement)
174 }
175 Some((TokenType::Keyword, "var"))
176 | Some((TokenType::Keyword, "let"))
177 | Some((TokenType::Keyword, "const")) => self.parse_variable_declaration(),
178 Some((TokenType::Keyword, "function")) => {
179 self.advance();
180 let generator = self.at_punct("*");
181 if generator {
182 self.advance();
183 }
184 self.parse_function_declaration(false, generator)
185 }
186 Some((TokenType::Keyword, "async")) => {
187 self.advance();
188 self.expect("function")?;
189 let generator = self.at_punct("*");
190 if generator {
191 self.advance();
192 }
193 self.parse_function_declaration(true, generator)
194 }
195 Some((TokenType::Keyword, "class")) => self.parse_class_declaration(),
196 Some((TokenType::Keyword, "if")) => self.parse_if_statement(),
197 Some((TokenType::Keyword, "for")) => self.parse_for_statement(),
198 Some((TokenType::Keyword, "while")) => self.parse_while_statement(),
199 Some((TokenType::Keyword, "do")) => self.parse_do_while_statement(),
200 Some((TokenType::Keyword, "switch")) => self.parse_switch_statement(),
201 Some((TokenType::Keyword, "try")) => self.parse_try_statement(),
202 Some((TokenType::Keyword, "with")) => self.parse_with_statement(),
203 Some((TokenType::Keyword, "return")) => self.parse_return_statement(),
204 Some((TokenType::Keyword, "throw")) => self.parse_throw_statement(),
205 Some((TokenType::Keyword, "break")) => self.parse_break_statement(),
206 Some((TokenType::Keyword, "continue")) => self.parse_continue_statement(),
207 Some((TokenType::Keyword, "debugger")) => {
208 self.advance();
209 self.expect_semicolon()?;
210 Ok(ASTNode::DebuggerStatement)
211 }
212 Some((TokenType::Keyword, "import")) if self.peek_at("(") => {
213 self.parse_expression_statement()
214 }
215 _ => self.parse_expression_statement_or_labelled(),
216 }
217 }
218
219 fn parse_block_statement(&mut self) -> Result<ASTNode, String> {
220 self.expect("{")?;
221 let (body, lines) = self.parse_statement_list_with_lines()?;
222 self.expect("}")?;
223 Ok(ASTNode::BlockStatement(BlockStatement { body, lines }))
224 }
225
226 fn parse_statement_list_with_lines(&mut self) -> Result<(Vec<ASTNode>, Vec<u32>), String> {
227 let mut stmts = Vec::new();
228 let mut lines = Vec::new();
229 while !self.is_eof() && !self.at_punct("}") {
230 let line = self.current.as_ref().map(|t| t.line).unwrap_or(0);
231 stmts.push(self.parse_statement()?);
232 lines.push(line);
233 }
234 Ok((stmts, lines))
235 }
236
237 fn parse_variable_declaration(&mut self) -> Result<ASTNode, String> {
238 let kind = match self.cur_value() {
239 "var" => VariableKind::Var,
240 "let" => VariableKind::Let,
241 "const" => VariableKind::Const,
242 _ => return Err(self.error("Expected var/let/const")),
243 };
244 self.advance();
245
246 let mut declarations = Vec::new();
247 loop {
248 let id = self.parse_binding_pattern()?;
249 let init = if self.at_punct("=") {
250 self.advance();
251 Some(self.parse_assignment_expression()?)
252 } else {
253 None
254 };
255 declarations.push(VariableDeclarator { id, init });
256 if self.at_punct(",") {
257 self.advance();
258 } else {
259 break;
260 }
261 }
262
263 if !self.at_punct(")") && !self.is_eof() {
264 self.expect_semicolon()?;
265 }
266
267 Ok(ASTNode::VariableDeclaration(VariableDeclaration {
268 kind,
269 declarations,
270 }))
271 }
272
273 fn parse_binding_pattern(&mut self) -> Result<BindingPattern, String> {
274 if self.at_punct("[") {
275 self.advance();
276 let mut elements = Vec::new();
277 while !self.at_punct("]") && !self.is_eof() {
278 if self.at_punct(",") {
279 elements.push(None);
280 self.advance();
281 continue;
282 }
283 let rest = if self.at_punct("...") {
284 self.advance();
285 let arg = self.parse_binding_pattern()?;
286 Some(Box::new(match arg {
287 BindingPattern::Identifier(name) => AssignmentTarget::Identifier(name),
288 other => AssignmentTarget::ArrayPattern(match other {
289 BindingPattern::ArrayPattern(p) => p,
290 BindingPattern::ObjectPattern(_) => {
291 return Err(self.error("rest element must be array/identifier"));
292 }
293 BindingPattern::AssignmentPattern(_) => {
294 return Err(self.error("rest element cannot be assignment pattern"));
295 }
296 BindingPattern::Identifier(_) => unreachable!(),
297 }),
298 }))
299 } else {
300 None
301 };
302 if let Some(arg) = rest {
303 if self.at_punct(",") {
304 self.advance();
305 }
306 elements.push(Some(PatternElement::RestElement(RestElement {
307 argument: arg,
308 })));
309 continue;
310 }
311 let pattern = self.parse_binding_pattern()?;
312 let elem = if self.at_punct("=") {
313 self.advance();
314 let right = self.parse_assignment_expression()?;
315 PatternElement::AssignmentPattern(AssignmentPattern {
316 left: Box::new(binding_to_target(pattern.clone())),
317 right: Box::new(right),
318 })
319 } else {
320 PatternElement::Pattern(binding_to_target(pattern))
321 };
322 elements.push(Some(elem));
323 if self.at_punct(",") {
324 self.advance();
325 }
326 }
327 self.expect("]")?;
328 return Ok(BindingPattern::ArrayPattern(ArrayPattern { elements }));
329 }
330
331 if self.at_punct("{") {
332 self.advance();
333 let mut properties = Vec::new();
334 while !self.at_punct("}") && !self.is_eof() {
335 if self.at_punct("...") {
336 self.advance();
337 let arg = self.parse_binding_pattern()?;
338 properties.push(ObjectPatternProperty::RestElement(RestElement {
339 argument: Box::new(binding_to_target(arg)),
340 }));
341 if self.at_punct(",") {
342 self.advance();
343 }
344 continue;
345 }
346 let (key, computed, shorthand) = self.parse_property_key()?;
347 let value = if self.at_punct(":") {
348 self.advance();
349 binding_to_target(self.parse_binding_pattern()?)
350 } else if shorthand
351 || (self.at_punct("=") && matches!(key, PropertyKey::Identifier(_)))
352 {
353 match &key {
354 PropertyKey::Identifier(name) => AssignmentTarget::Identifier(name.clone()),
355 _ => return Err(self.error("invalid shorthand pattern")),
356 }
357 } else {
358 return Err(self.error("expected ':' in object pattern"));
359 };
360
361 let value = if self.at_punct("=") {
362 self.advance();
363 let right = self.parse_assignment_expression()?;
364 AssignmentTarget::AssignmentPattern(AssignmentPattern {
365 left: Box::new(value),
366 right: Box::new(right),
367 })
368 } else {
369 value
370 };
371 properties.push(ObjectPatternProperty::Property {
372 key,
373 value,
374 computed,
375 shorthand,
376 });
377 if self.at_punct(",") {
378 self.advance();
379 }
380 }
381 self.expect("}")?;
382 return Ok(BindingPattern::ObjectPattern(ObjectPattern { properties }));
383 }
384
385 let name = self.cur_value().to_string();
386 if !self.is_identifier_name() {
387 return Err(self.error("expected identifier"));
388 }
389 self.advance();
390 Ok(BindingPattern::Identifier(name))
391 }
392
393 fn is_identifier_name(&self) -> bool {
394 matches!(
395 self.cur_type(),
396 Some(TokenType::Identifier) | Some(TokenType::Keyword)
397 ) && !matches!(self.cur_value(), "true" | "false" | "null")
398 }
399
400 fn parse_function_declaration(
401 &mut self,
402 is_async: bool,
403 generator: bool,
404 ) -> Result<ASTNode, String> {
405 let name = match self.cur_type() {
406 Some(TokenType::Identifier) | Some(TokenType::Keyword) => {
407 let n = self.cur_value().to_string();
408 self.advance();
409 n
410 }
411 _ => return Err(self.error("expected function name")),
412 };
413 self.expect("(")?;
414 let params = self.parse_parameter_list()?;
415 self.expect(")")?;
416 let body = self.parse_block_body()?;
417 Ok(ASTNode::FunctionDeclaration(FunctionDeclaration {
418 name,
419 params,
420 body,
421 generator,
422 is_async,
423 }))
424 }
425
426 fn parse_function_expression(
427 &mut self,
428 is_async: bool,
429 generator: bool,
430 ) -> Result<Expression, String> {
431 let name = if matches!(
432 self.cur_type(),
433 Some(TokenType::Identifier) | Some(TokenType::Keyword)
434 ) && !self.at_punct("(")
435 {
436 let n = self.cur_value().to_string();
437 self.advance();
438 Some(n)
439 } else {
440 None
441 };
442 self.expect("(")?;
443 let params = self.parse_parameter_list()?;
444 self.expect(")")?;
445 let body = self.parse_block_body()?;
446 Ok(Expression::FunctionExpression(FunctionExpression {
447 name,
448 params,
449 body,
450 generator,
451 is_async,
452 }))
453 }
454
455 fn parse_parameter_list(&mut self) -> Result<Vec<Parameter>, String> {
456 let mut params = Vec::new();
457 while !self.at_punct(")") && !self.is_eof() {
458 if self.at_punct("...") {
459 self.advance();
460 let arg = self.parse_binding_pattern()?;
461 params.push(Parameter::RestElement(RestElement {
462 argument: Box::new(binding_to_target(arg)),
463 }));
464 break;
465 }
466 let pattern = self.parse_binding_pattern()?;
467 if self.at_punct("=") {
468 self.advance();
469 let right = self.parse_assignment_expression()?;
470 params.push(Parameter::AssignmentPattern(AssignmentPattern {
471 left: Box::new(binding_to_target(pattern)),
472 right: Box::new(right),
473 }));
474 } else {
475 match pattern {
476 BindingPattern::Identifier(name) => params.push(Parameter::Identifier(name)),
477 other => params.push(Parameter::Pattern(other)),
478 }
479 }
480 if self.at_punct(",") {
481 self.advance();
482 }
483 }
484 Ok(params)
485 }
486
487 fn parse_expression_no_in(&mut self) -> Result<Expression, String> {
488 let prev_allow_in = self.allow_in;
489 self.allow_in = false;
490 let result = self.parse_expression();
491 self.allow_in = prev_allow_in;
492 result
493 }
494
495 fn parse_assignment_expression_no_in(&mut self) -> Result<Expression, String> {
496 let prev_allow_in = self.allow_in;
497 self.allow_in = false;
498 let result = self.parse_assignment_expression();
499 self.allow_in = prev_allow_in;
500 result
501 }
502
503 fn parse_block_body(&mut self) -> Result<BlockStatement, String> {
504 self.expect("{")?;
505 let (body, lines) = self.parse_statement_list_with_lines()?;
506 self.expect("}")?;
507 Ok(BlockStatement { body, lines })
508 }
509
510 fn parse_class_declaration(&mut self) -> Result<ASTNode, String> {
511 self.expect("class")?;
512 let name = self.cur_value().to_string();
513 self.advance();
514 let super_class = if self.at_keyword("extends") {
515 self.advance();
516 Some(Box::new(self.parse_assignment_expression()?))
517 } else {
518 None
519 };
520 self.expect("{")?;
521 let body = self.parse_class_body()?;
522 self.expect("}")?;
523 Ok(ASTNode::ClassDeclaration(ClassDeclaration {
524 name,
525 super_class,
526 body,
527 }))
528 }
529
530 fn parse_class_expression(&mut self) -> Result<Expression, String> {
531 self.expect("class")?;
532 let name = if self.is_identifier_name() && !self.at_keyword("extends") {
533 let n = self.cur_value().to_string();
534 self.advance();
535 Some(n)
536 } else {
537 None
538 };
539 let super_class = if self.at_keyword("extends") {
540 self.advance();
541 Some(Box::new(self.parse_assignment_expression()?))
542 } else {
543 None
544 };
545 self.expect("{")?;
546 let body = self.parse_class_body()?;
547 self.expect("}")?;
548 Ok(Expression::ClassExpression(ClassExpression {
549 name,
550 super_class,
551 body,
552 }))
553 }
554
555 fn parse_class_body(&mut self) -> Result<ClassBody, String> {
556 let mut elements = Vec::new();
557 while !self.at_punct("}") && !self.is_eof() {
558 if self.at_punct(";") {
559 self.advance();
560 continue;
561 }
562
563 let is_static = if self.at_keyword("static") {
564 self.advance();
565 true
566 } else {
567 false
568 };
569
570 if is_static && self.at_punct("{") {
571 self.expect("{")?;
572 let (body, lines) = self.parse_statement_list_with_lines()?;
573 self.expect("}")?;
574 elements.push(ClassElement::StaticBlock(StaticBlock { body, lines }));
575 continue;
576 }
577
578 let mut is_async = false;
579 if self.at_keyword("async")
580 && !self.peek_at(";")
581 && !self.peek_at("=")
582 && !self.peek_at("}")
583 {
584 self.advance();
585 is_async = true;
586 }
587
588 let mut is_generator = false;
589 if self.at_punct("*") {
590 self.advance();
591 is_generator = true;
592 }
593
594 let method_kind = if self.at_keyword("get") && !self.peek_at("(") && !self.peek_at(",")
595 {
596 self.advance();
597 MethodKind::Get
598 } else if self.at_keyword("set") && !self.peek_at("(") && !self.peek_at(",") {
599 self.advance();
600 MethodKind::Set
601 } else if is_static && self.at_keyword("constructor") {
602 MethodKind::Constructor
603 } else {
604 MethodKind::Method
605 };
606
607 let is_private = self.cur_type() == Some(TokenType::PrivateIdentifier);
608 let (name, _computed, _shorthand) = self.parse_property_key()?;
609
610 if self.at_punct("=") {
611 self.advance();
612 let value = Some(self.parse_assignment_expression()?);
613 elements.push(ClassElement::Property(ClassProperty {
614 name,
615 value,
616 is_static,
617 is_private,
618 }));
619 if self.at_punct(";") {
620 self.advance();
621 }
622 continue;
623 }
624
625 if self.at_punct(";") {
626 self.advance();
627 elements.push(ClassElement::Property(ClassProperty {
628 name,
629 value: None,
630 is_static,
631 is_private,
632 }));
633 continue;
634 }
635
636 if !self.at_punct("(") {
637 elements.push(ClassElement::Property(ClassProperty {
638 name,
639 value: None,
640 is_static,
641 is_private,
642 }));
643 continue;
644 }
645
646 self.expect("(")?;
647 let params = self.parse_parameter_list()?;
648 self.expect(")")?;
649 let body = self.parse_block_body()?;
650
651 let is_constructor_name =
652 matches!(&name, PropertyKey::Identifier(n) if n == "constructor");
653 let actual_kind = if !is_static && is_constructor_name {
654 MethodKind::Constructor
655 } else {
656 method_kind
657 };
658
659 elements.push(ClassElement::Method(ClassMethod {
660 name,
661 params,
662 body,
663 kind: actual_kind,
664 is_async,
665 generator: is_generator,
666 is_static,
667 is_private,
668 }));
669 }
670 Ok(ClassBody { elements })
671 }
672
673 fn parse_if_statement(&mut self) -> Result<ASTNode, String> {
674 self.expect("if")?;
675 self.expect("(")?;
676 let test = self.parse_expression()?;
677 self.expect(")")?;
678 let consequent = self.parse_statement()?;
679 let alternate = if self.at_keyword("else") {
680 self.advance();
681 Some(Box::new(self.parse_statement()?))
682 } else {
683 None
684 };
685 Ok(ASTNode::IfStatement(IfStatement {
686 test,
687 consequent: Box::new(consequent),
688 alternate,
689 }))
690 }
691
692 fn parse_for_statement(&mut self) -> Result<ASTNode, String> {
693 self.expect("for")?;
694 self.expect("(")?;
695
696 if self.at_punct(";") {
697 self.advance();
698 return self.parse_for_rest(None);
699 }
700
701 let is_await = if self.at_keyword("await") {
702 self.advance();
703 true
704 } else {
705 false
706 };
707
708 let is_var = matches!(self.cur_value(), "var" | "let" | "const");
709 if is_var {
710 let kind = match self.cur_value() {
711 "var" => VariableKind::Var,
712 "let" => VariableKind::Let,
713 "const" => VariableKind::Const,
714 _ => unreachable!(),
715 };
716 self.advance();
717 let mut declarations = Vec::new();
718 let id = self.parse_binding_pattern()?;
719
720 if self.at_keyword("in") {
721 self.advance();
722 let right = self.parse_expression()?;
723 self.expect(")")?;
724 let body = self.parse_statement()?;
725 let decl = VariableDeclaration {
726 kind,
727 declarations: vec![VariableDeclarator { id, init: None }],
728 };
729 return Ok(ASTNode::ForInStatement(ForInStatement {
730 left: ForInOfLeft::VariableDeclaration(decl),
731 right,
732 body: Box::new(body),
733 }));
734 }
735 if self.at_keyword("of") {
736 self.advance();
737 let right = self.parse_expression()?;
738 self.expect(")")?;
739 let body = self.parse_statement()?;
740 let decl = VariableDeclaration {
741 kind,
742 declarations: vec![VariableDeclarator { id, init: None }],
743 };
744 return Ok(ASTNode::ForOfStatement(ForOfStatement {
745 left: ForInOfLeft::VariableDeclaration(decl),
746 right,
747 body: Box::new(body),
748 is_await,
749 }));
750 }
751 let init = if self.at_punct("=") {
752 self.advance();
753 Some(self.parse_assignment_expression_no_in()?)
754 } else {
755 None
756 };
757 declarations.push(VariableDeclarator { id, init });
758 while self.at_punct(",") {
759 self.advance();
760 let id = self.parse_binding_pattern()?;
761 let init = if self.at_punct("=") {
762 self.advance();
763 Some(self.parse_assignment_expression_no_in()?)
764 } else {
765 None
766 };
767 declarations.push(VariableDeclarator { id, init });
768 }
769 let decl = VariableDeclaration { kind, declarations };
770 self.expect(";")?;
771 return self.parse_for_rest(Some(ForInit::VariableDeclaration(decl)));
772 }
773
774 let expr = self.parse_expression_no_in()?;
775 if self.at_keyword("in") {
776 self.advance();
777 let right = self.parse_expression()?;
778 self.expect(")")?;
779 let body = self.parse_statement()?;
780 return Ok(ASTNode::ForInStatement(ForInStatement {
781 left: ForInOfLeft::AssignmentTarget(expr_to_target(expr)?),
782 right,
783 body: Box::new(body),
784 }));
785 }
786 if self.at_keyword("of") {
787 self.advance();
788 let right = self.parse_expression()?;
789 self.expect(")")?;
790 let body = self.parse_statement()?;
791 return Ok(ASTNode::ForOfStatement(ForOfStatement {
792 left: ForInOfLeft::AssignmentTarget(expr_to_target(expr)?),
793 right,
794 body: Box::new(body),
795 is_await,
796 }));
797 }
798 self.expect(";")?;
799 self.parse_for_rest(Some(ForInit::Expression(expr)))
800 }
801
802 fn parse_for_rest(&mut self, init: Option<ForInit>) -> Result<ASTNode, String> {
803 let test = if self.at_punct(";") {
804 None
805 } else {
806 Some(self.parse_expression()?)
807 };
808 self.expect(";")?;
809 let update = if self.at_punct(")") {
810 None
811 } else {
812 Some(self.parse_expression()?)
813 };
814 self.expect(")")?;
815 let body = self.parse_statement()?;
816 Ok(ASTNode::ForStatement(ForStatement {
817 init,
818 test,
819 update,
820 body: Box::new(body),
821 }))
822 }
823
824 fn parse_while_statement(&mut self) -> Result<ASTNode, String> {
825 self.expect("while")?;
826 self.expect("(")?;
827 let test = self.parse_expression()?;
828 self.expect(")")?;
829 let body = self.parse_statement()?;
830 Ok(ASTNode::WhileStatement(WhileStatement {
831 test,
832 body: Box::new(body),
833 }))
834 }
835
836 fn parse_do_while_statement(&mut self) -> Result<ASTNode, String> {
837 self.expect("do")?;
838 let body = self.parse_statement()?;
839 self.expect_keyword("while")?;
840 self.expect("(")?;
841 let test = self.parse_expression()?;
842 self.expect(")")?;
843 self.expect_semicolon()?;
844 Ok(ASTNode::DoWhileStatement(DoWhileStatement {
845 body: Box::new(body),
846 test,
847 }))
848 }
849
850 fn expect_keyword(&mut self, kw: &str) -> Result<(), String> {
851 if self.at_keyword(kw) {
852 self.advance();
853 Ok(())
854 } else {
855 Err(self.error(&format!("Expected keyword '{}'", kw)))
856 }
857 }
858
859 fn parse_switch_statement(&mut self) -> Result<ASTNode, String> {
860 self.expect("switch")?;
861 self.expect("(")?;
862 let discriminant = self.parse_expression()?;
863 self.expect(")")?;
864 self.expect("{")?;
865 let mut cases = Vec::new();
866 while !self.at_punct("}") && !self.is_eof() {
867 if self.at_keyword("default") {
868 self.advance();
869 self.expect(":")?;
870 let consequent = self.parse_statement_list_until_case()?;
871 cases.push(SwitchCase {
872 test: None,
873 consequent,
874 });
875 } else {
876 self.expect_keyword("case")?;
877 let test = self.parse_expression()?;
878 self.expect(":")?;
879 let consequent = self.parse_statement_list_until_case()?;
880 cases.push(SwitchCase {
881 test: Some(test),
882 consequent,
883 });
884 }
885 }
886 self.expect("}")?;
887 Ok(ASTNode::SwitchStatement(SwitchStatement {
888 discriminant,
889 cases,
890 }))
891 }
892
893 fn parse_statement_list_until_case(&mut self) -> Result<Vec<ASTNode>, String> {
894 let (stmts, _) = self.parse_statement_list_until_case_with_lines()?;
895 Ok(stmts)
896 }
897
898 fn parse_statement_list_until_case_with_lines(
899 &mut self,
900 ) -> Result<(Vec<ASTNode>, Vec<u32>), String> {
901 let mut stmts = Vec::new();
902 let mut lines = Vec::new();
903 while !self.is_eof()
904 && !self.at_punct("}")
905 && !self.at_keyword("case")
906 && !self.at_keyword("default")
907 {
908 let line = self.current.as_ref().map(|t| t.line).unwrap_or(0);
909 stmts.push(self.parse_statement()?);
910 lines.push(line);
911 }
912 Ok((stmts, lines))
913 }
914
915 fn parse_try_statement(&mut self) -> Result<ASTNode, String> {
916 self.expect("try")?;
917 let block = self.parse_block_body()?;
918 let handler = if self.at_keyword("catch") {
919 self.advance();
920 let param = if self.at_punct("(") {
921 self.advance();
922 let p = self.parse_binding_pattern()?;
923 self.expect(")")?;
924 Some(p)
925 } else {
926 None
927 };
928 let body = self.parse_block_body()?;
929 Some(CatchClause { param, body })
930 } else {
931 None
932 };
933 let finalizer = if self.at_keyword("finally") {
934 self.advance();
935 Some(self.parse_block_body()?)
936 } else {
937 None
938 };
939 Ok(ASTNode::TryStatement(TryStatement {
940 block,
941 handler,
942 finalizer,
943 }))
944 }
945
946 fn parse_with_statement(&mut self) -> Result<ASTNode, String> {
947 self.expect("with")?;
948 self.expect("(")?;
949 let object = self.parse_expression()?;
950 self.expect(")")?;
951 let body = self.parse_statement()?;
952 Ok(ASTNode::WithStatement(WithStatement {
953 object,
954 body: Box::new(body),
955 }))
956 }
957
958 fn has_line_terminator(&self) -> bool {
959 self.current
960 .as_ref()
961 .map_or(false, |t| t.line > self.saved_line)
962 }
963
964 fn parse_return_statement(&mut self) -> Result<ASTNode, String> {
965 self.expect("return")?;
966 let argument = if self.is_eof()
967 || self.at_punct(";")
968 || self.at_punct("}")
969 || self.has_line_terminator()
970 {
971 None
972 } else {
973 Some(self.parse_expression()?)
974 };
975 self.expect_semicolon()?;
976 Ok(ASTNode::ReturnStatement(ReturnStatement { argument }))
977 }
978
979 fn parse_throw_statement(&mut self) -> Result<ASTNode, String> {
980 self.expect("throw")?;
981 let argument = self.parse_expression()?;
982 self.expect_semicolon()?;
983 Ok(ASTNode::ThrowStatement(ThrowStatement { argument }))
984 }
985
986 fn parse_break_statement(&mut self) -> Result<ASTNode, String> {
987 self.expect("break")?;
988 let label = if !self.has_line_terminator()
989 && self.is_identifier_name()
990 && !self.at_punct(";")
991 && !self.is_eof()
992 {
993 Some(self.cur_value().to_string())
994 } else {
995 None
996 };
997 if label.is_some() {
998 self.advance();
999 }
1000 self.expect_semicolon()?;
1001 Ok(ASTNode::BreakStatement(BreakStatement { label }))
1002 }
1003
1004 fn parse_continue_statement(&mut self) -> Result<ASTNode, String> {
1005 self.expect("continue")?;
1006 let label = if !self.has_line_terminator()
1007 && self.is_identifier_name()
1008 && !self.at_punct(";")
1009 && !self.is_eof()
1010 {
1011 Some(self.cur_value().to_string())
1012 } else {
1013 None
1014 };
1015 if label.is_some() {
1016 self.advance();
1017 }
1018 self.expect_semicolon()?;
1019 Ok(ASTNode::ContinueStatement(ContinueStatement { label }))
1020 }
1021
1022 fn parse_expression_statement_or_labelled(&mut self) -> Result<ASTNode, String> {
1023 if self.is_identifier_name() && self.peek_at(":") {
1024 let label = self.cur_value().to_string();
1025 self.advance();
1026 self.advance();
1027 let body = self.parse_statement()?;
1028 return Ok(ASTNode::LabelledStatement(LabelledStatement {
1029 label,
1030 body: Box::new(body),
1031 }));
1032 }
1033 self.parse_expression_statement()
1034 }
1035
1036 fn parse_expression_statement(&mut self) -> Result<ASTNode, String> {
1037 let expr = self.parse_expression()?;
1038 self.expect_semicolon()?;
1039 Ok(ASTNode::ExpressionStatement(ExpressionStatement {
1040 expression: expr,
1041 }))
1042 }
1043
1044 fn parse_import_declaration(&mut self) -> Result<ImportDeclaration, String> {
1045 self.expect("import")?;
1046 let mut specifiers = Vec::new();
1047
1048 if self.cur_type() == Some(TokenType::String) {
1049 let source = self.cur_value().to_string();
1050 self.advance();
1051 self.expect_semicolon()?;
1052 return Ok(ImportDeclaration { specifiers, source });
1053 }
1054
1055 if self.is_identifier_name() {
1056 let local = self.cur_value().to_string();
1057 self.advance();
1058 specifiers.push(ImportSpecifier::Default { local });
1059
1060 if self.at_punct(",") {
1061 self.advance();
1062 }
1063 }
1064
1065 if self.at_punct("*") {
1066 self.advance();
1067 self.expect_keyword("as")?;
1068 let local = self.cur_value().to_string();
1069 self.advance();
1070 specifiers.push(ImportSpecifier::Namespace { local });
1071 }
1072
1073 if self.at_punct("{") {
1074 self.advance();
1075 while !self.at_punct("}") && !self.is_eof() && !self.at_keyword("from") {
1076 if self.at_punct(",") {
1077 self.advance();
1078 continue;
1079 }
1080 let imported = self.cur_value().to_string();
1081 self.advance();
1082 let local = if self.at_keyword("as") {
1083 self.advance();
1084 self.cur_value().to_string()
1085 } else {
1086 imported.clone()
1087 };
1088 if !self.at_punct(",") && !self.at_punct("}") && !self.at_keyword("from") {
1089 self.advance();
1090 }
1091 specifiers.push(ImportSpecifier::Named { imported, local });
1092 }
1093 self.expect("}")?;
1094 }
1095
1096 self.expect_keyword("from")?;
1097 let source = self.cur_value().to_string();
1098 self.advance();
1099 self.expect_semicolon()?;
1100 Ok(ImportDeclaration { specifiers, source })
1101 }
1102
1103 fn parse_export_declaration(&mut self) -> Result<ASTNode, String> {
1104 self.expect("export")?;
1105
1106 if self.at_keyword("default") {
1107 self.advance();
1108 let decl = if self.at_keyword("function") {
1109 self.advance();
1110 let generator = self.at_punct("*");
1111 if generator {
1112 self.advance();
1113 }
1114 let func = self.parse_function_declaration_like(false, generator)?;
1115 ExportDefaultDeclarationKind::Function(func)
1116 } else if self.at_keyword("class") {
1117 self.advance();
1118 let cls = self.parse_class_declaration_inner()?;
1119 ExportDefaultDeclarationKind::Class(cls)
1120 } else if self.at_keyword("async") {
1121 self.advance();
1122 self.expect("function")?;
1123 let generator = self.at_punct("*");
1124 if generator {
1125 self.advance();
1126 }
1127 let func = self.parse_function_declaration_like(true, generator)?;
1128 ExportDefaultDeclarationKind::Function(func)
1129 } else {
1130 let expr = self.parse_assignment_expression()?;
1131 ExportDefaultDeclarationKind::Expression(expr)
1132 };
1133 self.expect_semicolon()?;
1134 return Ok(ASTNode::ExportDefaultDeclaration(
1135 ExportDefaultDeclaration { declaration: decl },
1136 ));
1137 }
1138
1139 if self.at_punct("*") {
1140 self.advance();
1141 self.expect_keyword("from")?;
1142 let source = self.cur_value().to_string();
1143 self.advance();
1144 self.expect_semicolon()?;
1145 return Ok(ASTNode::ExportAllDeclaration(ExportAllDeclaration {
1146 source,
1147 exported: None,
1148 }));
1149 }
1150
1151 if self.at_punct("{") {
1152 self.advance();
1153 let mut specifiers = Vec::new();
1154 while !self.at_punct("}") && !self.is_eof() {
1155 let local = self.cur_value().to_string();
1156 self.advance();
1157 let exported = if self.at_keyword("as") {
1158 self.advance();
1159 let name = self.cur_value().to_string();
1160 self.advance();
1161 name
1162 } else {
1163 local.clone()
1164 };
1165 specifiers.push(ExportSpecifier { exported, local });
1166 if self.at_punct(",") {
1167 self.advance();
1168 }
1169 }
1170 self.expect("}")?;
1171 let source = if self.at_keyword("from") {
1172 self.advance();
1173 let s = self.cur_value().to_string();
1174 self.advance();
1175 Some(s)
1176 } else {
1177 None
1178 };
1179 self.expect_semicolon()?;
1180 return Ok(ASTNode::ExportNamedDeclaration(ExportNamedDeclaration {
1181 declaration: None,
1182 specifiers,
1183 source,
1184 }));
1185 }
1186
1187 if self.at_keyword("var") || self.at_keyword("let") || self.at_keyword("const") {
1188 let decl = self.parse_variable_declaration()?;
1189 match decl {
1190 ASTNode::VariableDeclaration(v) => {
1191 return Ok(ASTNode::ExportNamedDeclaration(ExportNamedDeclaration {
1192 declaration: Some(ExportDeclaration::Variable(v)),
1193 specifiers: vec![],
1194 source: None,
1195 }));
1196 }
1197 _ => unreachable!(),
1198 }
1199 }
1200 if self.at_keyword("function") {
1201 self.advance();
1202 let generator = self.at_punct("*");
1203 if generator {
1204 self.advance();
1205 }
1206 let func = self.parse_function_declaration_like(false, generator)?;
1207 return Ok(ASTNode::ExportNamedDeclaration(ExportNamedDeclaration {
1208 declaration: Some(ExportDeclaration::Function(func)),
1209 specifiers: vec![],
1210 source: None,
1211 }));
1212 }
1213 if self.at_keyword("async") {
1214 self.advance();
1215 self.expect("function")?;
1216 let generator = self.at_punct("*");
1217 if generator {
1218 self.advance();
1219 }
1220 let func = self.parse_function_declaration_like(true, generator)?;
1221 return Ok(ASTNode::ExportNamedDeclaration(ExportNamedDeclaration {
1222 declaration: Some(ExportDeclaration::Function(func)),
1223 specifiers: vec![],
1224 source: None,
1225 }));
1226 }
1227 if self.at_keyword("class") {
1228 self.advance();
1229 let cls = self.parse_class_declaration_inner()?;
1230 return Ok(ASTNode::ExportNamedDeclaration(ExportNamedDeclaration {
1231 declaration: Some(ExportDeclaration::Class(cls)),
1232 specifiers: vec![],
1233 source: None,
1234 }));
1235 }
1236
1237 Err(self.error("expected export declaration"))
1238 }
1239
1240 fn parse_function_declaration_like(
1241 &mut self,
1242 is_async: bool,
1243 generator: bool,
1244 ) -> Result<FunctionDeclaration, String> {
1245 let name = if matches!(
1246 self.cur_type(),
1247 Some(TokenType::Identifier) | Some(TokenType::Keyword)
1248 ) && !self.at_punct("(")
1249 {
1250 let n = self.cur_value().to_string();
1251 self.advance();
1252 n
1253 } else {
1254 String::new()
1255 };
1256 self.expect("(")?;
1257 let params = self.parse_parameter_list()?;
1258 self.expect(")")?;
1259 let body = self.parse_block_body()?;
1260 Ok(FunctionDeclaration {
1261 name,
1262 params,
1263 body,
1264 generator,
1265 is_async,
1266 })
1267 }
1268
1269 fn parse_class_declaration_inner(&mut self) -> Result<ClassDeclaration, String> {
1270 let name = self.cur_value().to_string();
1271 self.advance();
1272 let super_class = if self.at_keyword("extends") {
1273 self.advance();
1274 Some(Box::new(self.parse_assignment_expression()?))
1275 } else {
1276 None
1277 };
1278 self.expect("{")?;
1279 let body = self.parse_class_body()?;
1280 self.expect("}")?;
1281 Ok(ClassDeclaration {
1282 name,
1283 super_class,
1284 body,
1285 })
1286 }
1287
1288 fn parse_expression(&mut self) -> Result<Expression, String> {
1289 let expr = self.parse_assignment_expression()?;
1290 if self.at_punct(",") {
1291 let mut exprs = vec![expr];
1292 while self.at_punct(",") {
1293 self.advance();
1294 exprs.push(self.parse_assignment_expression()?);
1295 }
1296 return Ok(Expression::SequenceExpression(SequenceExpression {
1297 expressions: exprs,
1298 }));
1299 }
1300 Ok(expr)
1301 }
1302
1303 fn parse_assignment_expression(&mut self) -> Result<Expression, String> {
1304 if self.at_keyword("async") && self.peek_at("function") {
1305 self.advance();
1306 self.expect("function")?;
1307 let generator = self.at_punct("*");
1308 if generator {
1309 self.advance();
1310 }
1311 return self.parse_function_expression(true, generator);
1312 }
1313
1314 if self.at_keyword("async") {
1315 if self.peek_at("(") || (self.peek_value().map_or(false, |v| v != "function")) {
1316 let saved_pos = self.lexer.pos();
1317 let saved_kind = self.lexer.last_token_kind();
1318 self.advance();
1319 if self.at_keyword("function") {
1320 self.lexer.set_pos(saved_pos);
1321 self.lexer.set_last_token_kind(saved_kind);
1322 self.current = self.lexer.next_token();
1323 self.peek_token = self.lexer.next_token();
1324 } else if let Some(arrow) = self.try_parse_arrow_function(true)? {
1325 return Ok(arrow);
1326 } else {
1327 self.lexer.set_pos(saved_pos);
1328 self.lexer.set_last_token_kind(saved_kind);
1329 self.current = self.lexer.next_token();
1330 self.peek_token = self.lexer.next_token();
1331 }
1332 }
1333 }
1334
1335 if self.at_punct("(") || (self.is_identifier_name() && self.peek_at("=>")) {
1336 if let Some(arrow) = self.try_parse_arrow_function(false)? {
1337 return Ok(arrow);
1338 }
1339 }
1340
1341 let expr = self.parse_conditional_expression()?;
1342
1343 let assign_ops = [
1344 ("=", AssignOp::Assign),
1345 ("+=", AssignOp::AddAssign),
1346 ("-=", AssignOp::SubAssign),
1347 ("*=", AssignOp::MulAssign),
1348 ("/=", AssignOp::DivAssign),
1349 ("%=", AssignOp::ModAssign),
1350 ("**=", AssignOp::PowAssign),
1351 ("&=", AssignOp::BitAndAssign),
1352 ("|=", AssignOp::BitOrAssign),
1353 ("^=", AssignOp::BitXorAssign),
1354 ("<<=", AssignOp::ShlAssign),
1355 (">>=", AssignOp::ShrAssign),
1356 (">>>=", AssignOp::UShrAssign),
1357 ("&&=", AssignOp::LogicalAndAssign),
1358 ("||=", AssignOp::LogicalOrAssign),
1359 ("??=", AssignOp::NullishAssign),
1360 ];
1361 for (op_str, op) in &assign_ops {
1362 if self.at_punct(op_str) {
1363 self.advance();
1364 let right = self.parse_assignment_expression()?;
1365 let left = expr_to_target(expr)?;
1366 return Ok(Expression::AssignmentExpression(AssignmentExpression {
1367 op: op.clone(),
1368 left,
1369 right: Box::new(right),
1370 }));
1371 }
1372 }
1373
1374 Ok(expr)
1375 }
1376
1377 fn try_parse_arrow_function(&mut self, is_async: bool) -> Result<Option<Expression>, String> {
1378 let saved_pos = self.lexer.pos();
1379 let saved_kind = self.lexer.last_token_kind();
1380 let saved_cur = self.current.clone();
1381 let saved_peek = self.peek_token.clone();
1382
1383 let params = if self.at_punct("(") {
1384 self.advance();
1385 let p = match self.parse_parameter_list() {
1386 Ok(p) => p,
1387 Err(_) => {
1388 self.restore(saved_pos, saved_kind, saved_cur, saved_peek);
1389 return Ok(None);
1390 }
1391 };
1392 if !self.at_punct(")") {
1393 self.restore(saved_pos, saved_kind, saved_cur, saved_peek);
1394 return Ok(None);
1395 }
1396 self.advance();
1397 p
1398 } else if self.is_identifier_name() {
1399 let name = self.cur_value().to_string();
1400 self.advance();
1401 vec![Parameter::Identifier(name)]
1402 } else {
1403 self.restore(saved_pos, saved_kind, saved_cur, saved_peek);
1404 return Ok(None);
1405 };
1406
1407 if !self.at_punct("=>") {
1408 self.restore(saved_pos, saved_kind, saved_cur, saved_peek);
1409 return Ok(None);
1410 }
1411 self.advance();
1412
1413 let body = if self.at_punct("{") {
1414 ArrowBody::Block(self.parse_block_body()?)
1415 } else {
1416 ArrowBody::Expression(Box::new(self.parse_assignment_expression()?))
1417 };
1418
1419 Ok(Some(Expression::ArrowFunction(ArrowFunction {
1420 params,
1421 body,
1422 is_async,
1423 })))
1424 }
1425
1426 fn restore(
1427 &mut self,
1428 pos: usize,
1429 kind: crate::compiler::lexer::LastTokenKind,
1430 cur: Option<Token>,
1431 peek: Option<Token>,
1432 ) {
1433 self.lexer.set_pos(pos);
1434 self.lexer.set_last_token_kind(kind);
1435 self.current = cur;
1436 self.peek_token = peek;
1437 }
1438
1439 fn parse_conditional_expression(&mut self) -> Result<Expression, String> {
1440 let expr = self.parse_logical_or()?;
1441 if self.at_punct("?") {
1442 self.advance();
1443 let consequent = self.parse_assignment_expression()?;
1444 self.expect(":")?;
1445 let alternate = self.parse_assignment_expression()?;
1446 return Ok(Expression::ConditionalExpression(ConditionalExpression {
1447 test: Box::new(expr),
1448 consequent: Box::new(consequent),
1449 alternate: Box::new(alternate),
1450 }));
1451 }
1452 Ok(expr)
1453 }
1454
1455 fn parse_logical_or(&mut self) -> Result<Expression, String> {
1456 let mut left = self.parse_logical_and()?;
1457 while self.at_punct("||") || self.at_punct("??") {
1458 let op = if self.at_punct("||") {
1459 self.advance();
1460 LogicalOp::Or
1461 } else {
1462 self.advance();
1463 LogicalOp::NullishCoalescing
1464 };
1465 let right = self.parse_logical_and()?;
1466 left = Expression::LogicalExpression(LogicalExpression {
1467 op,
1468 left: Box::new(left),
1469 right: Box::new(right),
1470 });
1471 }
1472 Ok(left)
1473 }
1474
1475 fn parse_logical_and(&mut self) -> Result<Expression, String> {
1476 let mut left = self.parse_bitwise_or()?;
1477 while self.at_punct("&&") {
1478 self.advance();
1479 let right = self.parse_bitwise_or()?;
1480 left = Expression::LogicalExpression(LogicalExpression {
1481 op: LogicalOp::And,
1482 left: Box::new(left),
1483 right: Box::new(right),
1484 });
1485 }
1486 Ok(left)
1487 }
1488
1489 fn parse_bitwise_or(&mut self) -> Result<Expression, String> {
1490 let mut left = self.parse_bitwise_xor()?;
1491 while self.at_punct("|") {
1492 self.advance();
1493 let right = self.parse_bitwise_xor()?;
1494 left = Expression::BinaryExpression(BinaryExpression {
1495 op: BinaryOp::BitOr,
1496 left: Box::new(left),
1497 right: Box::new(right),
1498 });
1499 }
1500 Ok(left)
1501 }
1502
1503 fn parse_bitwise_xor(&mut self) -> Result<Expression, String> {
1504 let mut left = self.parse_bitwise_and()?;
1505 while self.at_punct("^") {
1506 self.advance();
1507 let right = self.parse_bitwise_and()?;
1508 left = Expression::BinaryExpression(BinaryExpression {
1509 op: BinaryOp::BitXor,
1510 left: Box::new(left),
1511 right: Box::new(right),
1512 });
1513 }
1514 Ok(left)
1515 }
1516
1517 fn parse_bitwise_and(&mut self) -> Result<Expression, String> {
1518 let mut left = self.parse_equality()?;
1519 while self.at_punct("&") {
1520 self.advance();
1521 let right = self.parse_equality()?;
1522 left = Expression::BinaryExpression(BinaryExpression {
1523 op: BinaryOp::BitAnd,
1524 left: Box::new(left),
1525 right: Box::new(right),
1526 });
1527 }
1528 Ok(left)
1529 }
1530
1531 fn parse_equality(&mut self) -> Result<Expression, String> {
1532 let mut left = self.parse_relational()?;
1533 loop {
1534 let op = if self.at_punct("==") {
1535 Some(BinaryOp::Eq)
1536 } else if self.at_punct("!=") {
1537 Some(BinaryOp::Neq)
1538 } else if self.at_punct("===") {
1539 Some(BinaryOp::StrictEq)
1540 } else if self.at_punct("!==") {
1541 Some(BinaryOp::StrictNeq)
1542 } else {
1543 None
1544 };
1545 if let Some(op) = op {
1546 self.advance();
1547 let right = self.parse_relational()?;
1548 left = Expression::BinaryExpression(BinaryExpression {
1549 op,
1550 left: Box::new(left),
1551 right: Box::new(right),
1552 });
1553 } else {
1554 break;
1555 }
1556 }
1557 Ok(left)
1558 }
1559
1560 fn parse_relational(&mut self) -> Result<Expression, String> {
1561 if self.cur_type() == Some(TokenType::PrivateIdentifier) {
1562 let name = self.cur_value().to_string();
1563 self.advance();
1564 if self.at_keyword("in") {
1565 self.advance();
1566 let right = self.parse_shift()?;
1567 return Ok(Expression::BinaryExpression(BinaryExpression {
1568 op: BinaryOp::In,
1569 left: Box::new(Expression::PrivateIdentifier(name)),
1570 right: Box::new(right),
1571 }));
1572 } else {
1573 return Err(self.error("Unexpected private identifier"));
1574 }
1575 }
1576
1577 let mut left = self.parse_shift()?;
1578 loop {
1579 let op = if self.at_punct("<=") {
1580 Some(BinaryOp::Lte)
1581 } else if self.at_punct(">=") {
1582 Some(BinaryOp::Gte)
1583 } else if self.at_punct("<") {
1584 Some(BinaryOp::Lt)
1585 } else if self.at_punct(">") {
1586 Some(BinaryOp::Gt)
1587 } else if self.allow_in && self.at_keyword("in") {
1588 Some(BinaryOp::In)
1589 } else if self.at_keyword("instanceof") {
1590 Some(BinaryOp::InstanceOf)
1591 } else {
1592 None
1593 };
1594 if let Some(op) = op {
1595 self.advance();
1596 let right = self.parse_shift()?;
1597 left = Expression::BinaryExpression(BinaryExpression {
1598 op,
1599 left: Box::new(left),
1600 right: Box::new(right),
1601 });
1602 } else {
1603 break;
1604 }
1605 }
1606 Ok(left)
1607 }
1608
1609 fn parse_shift(&mut self) -> Result<Expression, String> {
1610 let mut left = self.parse_additive()?;
1611 loop {
1612 let op = if self.at_punct(">>>") {
1613 Some(BinaryOp::UShr)
1614 } else if self.at_punct(">>") {
1615 Some(BinaryOp::Shr)
1616 } else if self.at_punct("<<") {
1617 Some(BinaryOp::Shl)
1618 } else {
1619 None
1620 };
1621 if let Some(op) = op {
1622 self.advance();
1623 let right = self.parse_additive()?;
1624 left = Expression::BinaryExpression(BinaryExpression {
1625 op,
1626 left: Box::new(left),
1627 right: Box::new(right),
1628 });
1629 } else {
1630 break;
1631 }
1632 }
1633 Ok(left)
1634 }
1635
1636 fn parse_additive(&mut self) -> Result<Expression, String> {
1637 let mut left = self.parse_multiplicative()?;
1638 loop {
1639 let op = if self.at_punct("+") {
1640 Some(BinaryOp::Add)
1641 } else if self.at_punct("-") {
1642 Some(BinaryOp::Sub)
1643 } else {
1644 None
1645 };
1646 if let Some(op) = op {
1647 self.advance();
1648 let right = self.parse_multiplicative()?;
1649 left = Expression::BinaryExpression(BinaryExpression {
1650 op,
1651 left: Box::new(left),
1652 right: Box::new(right),
1653 });
1654 } else {
1655 break;
1656 }
1657 }
1658 Ok(left)
1659 }
1660
1661 fn parse_multiplicative(&mut self) -> Result<Expression, String> {
1662 let mut left = self.parse_exponentiation()?;
1663 loop {
1664 let op = if self.at_punct("*") {
1665 Some(BinaryOp::Mul)
1666 } else if self.at_punct("/") {
1667 Some(BinaryOp::Div)
1668 } else if self.at_punct("%") {
1669 Some(BinaryOp::Mod)
1670 } else {
1671 None
1672 };
1673 if let Some(op) = op {
1674 self.advance();
1675 let right = self.parse_exponentiation()?;
1676 left = Expression::BinaryExpression(BinaryExpression {
1677 op,
1678 left: Box::new(left),
1679 right: Box::new(right),
1680 });
1681 } else {
1682 break;
1683 }
1684 }
1685 Ok(left)
1686 }
1687
1688 fn parse_exponentiation(&mut self) -> Result<Expression, String> {
1689 let left = self.parse_unary()?;
1690 if self.at_punct("**") {
1691 self.advance();
1692 let right = self.parse_exponentiation()?;
1693 return Ok(Expression::BinaryExpression(BinaryExpression {
1694 op: BinaryOp::Pow,
1695 left: Box::new(left),
1696 right: Box::new(right),
1697 }));
1698 }
1699 Ok(left)
1700 }
1701
1702 fn parse_unary(&mut self) -> Result<Expression, String> {
1703 if self.at_punct("!") {
1704 self.advance();
1705 let arg = self.parse_unary()?;
1706 return Ok(Expression::UnaryExpression(UnaryExpression {
1707 op: UnaryOp::Not,
1708 argument: Box::new(arg),
1709 prefix: true,
1710 }));
1711 }
1712
1713 if self.at_punct("~") {
1714 self.advance();
1715 let arg = self.parse_unary()?;
1716 return Ok(Expression::UnaryExpression(UnaryExpression {
1717 op: UnaryOp::BitNot,
1718 argument: Box::new(arg),
1719 prefix: true,
1720 }));
1721 }
1722
1723 if self.at_punct("-") {
1724 self.advance();
1725 let arg = self.parse_unary()?;
1726 return Ok(Expression::UnaryExpression(UnaryExpression {
1727 op: UnaryOp::Minus,
1728 argument: Box::new(arg),
1729 prefix: true,
1730 }));
1731 }
1732
1733 if self.at_punct("+") && self.cur_type() == Some(TokenType::Punctuator) {
1734 self.advance();
1735 let arg = self.parse_unary()?;
1736 return Ok(Expression::UnaryExpression(UnaryExpression {
1737 op: UnaryOp::Plus,
1738 argument: Box::new(arg),
1739 prefix: true,
1740 }));
1741 }
1742 if self.at_keyword("typeof") {
1743 self.advance();
1744 let arg = self.parse_unary()?;
1745 return Ok(Expression::UnaryExpression(UnaryExpression {
1746 op: UnaryOp::TypeOf,
1747 argument: Box::new(arg),
1748 prefix: true,
1749 }));
1750 }
1751 if self.at_keyword("void") {
1752 self.advance();
1753 let arg = self.parse_unary()?;
1754 return Ok(Expression::UnaryExpression(UnaryExpression {
1755 op: UnaryOp::Void,
1756 argument: Box::new(arg),
1757 prefix: true,
1758 }));
1759 }
1760 if self.at_keyword("delete") {
1761 self.advance();
1762 let arg = self.parse_unary()?;
1763 return Ok(Expression::UnaryExpression(UnaryExpression {
1764 op: UnaryOp::Delete,
1765 argument: Box::new(arg),
1766 prefix: true,
1767 }));
1768 }
1769
1770 if self.at_punct("++") {
1771 self.advance();
1772 let arg = self.parse_unary()?;
1773 return Ok(Expression::UpdateExpression(UpdateExpression {
1774 op: UpdateOp::Increment,
1775 argument: Box::new(arg),
1776 prefix: true,
1777 }));
1778 }
1779 if self.at_punct("--") {
1780 self.advance();
1781 let arg = self.parse_unary()?;
1782 return Ok(Expression::UpdateExpression(UpdateExpression {
1783 op: UpdateOp::Decrement,
1784 argument: Box::new(arg),
1785 prefix: true,
1786 }));
1787 }
1788
1789 if self.at_keyword("await") {
1790 self.advance();
1791 let arg = self.parse_unary()?;
1792 return Ok(Expression::AwaitExpression(AwaitExpression {
1793 argument: Box::new(arg),
1794 }));
1795 }
1796
1797 self.parse_postfix()
1798 }
1799
1800 fn parse_postfix(&mut self) -> Result<Expression, String> {
1801 let expr = self.parse_member_expression()?;
1802
1803 if self.at_punct("++") && !self.has_line_terminator() {
1804 self.advance();
1805 return Ok(Expression::UpdateExpression(UpdateExpression {
1806 op: UpdateOp::Increment,
1807 argument: Box::new(expr),
1808 prefix: false,
1809 }));
1810 }
1811 if self.at_punct("--") && !self.has_line_terminator() {
1812 self.advance();
1813 return Ok(Expression::UpdateExpression(UpdateExpression {
1814 op: UpdateOp::Decrement,
1815 argument: Box::new(expr),
1816 prefix: false,
1817 }));
1818 }
1819
1820 Ok(expr)
1821 }
1822
1823 fn parse_member_expression(&mut self) -> Result<Expression, String> {
1824 let mut expr = self.parse_primary()?;
1825
1826 loop {
1827 if self.at_punct(".") {
1828 self.advance();
1829
1830 if self.cur_type() == Some(TokenType::PrivateIdentifier) {
1831 let name = self.cur_value().to_string();
1832 self.advance();
1833 expr = Expression::MemberExpression(MemberExpression {
1834 object: Box::new(expr),
1835 property: MemberProperty::PrivateIdentifier(name),
1836 computed: false,
1837 });
1838 } else {
1839 let name = self.cur_value().to_string();
1840 self.advance();
1841 expr = Expression::MemberExpression(MemberExpression {
1842 object: Box::new(expr),
1843 property: MemberProperty::Identifier(name),
1844 computed: false,
1845 });
1846 }
1847 } else if self.at_punct("?.") {
1848 self.advance();
1849 if self.at_punct("[") {
1850 self.advance();
1851 let prop = self.parse_expression()?;
1852 self.expect("]")?;
1853 expr = Expression::OptionalMemberExpression(OptionalMemberExpression {
1854 object: Box::new(expr),
1855 property: MemberProperty::Computed(Box::new(prop)),
1856 computed: true,
1857 optional: true,
1858 });
1859 } else if self.at_punct("(") {
1860 let args = self.parse_arguments()?;
1861 expr = Expression::OptionalCallExpression(OptionalCallExpression {
1862 callee: Box::new(expr),
1863 arguments: args,
1864 optional: true,
1865 });
1866 } else {
1867 let name = self.cur_value().to_string();
1868 self.advance();
1869 expr = Expression::OptionalMemberExpression(OptionalMemberExpression {
1870 object: Box::new(expr),
1871 property: MemberProperty::Identifier(name),
1872 computed: false,
1873 optional: true,
1874 });
1875 }
1876 } else if self.at_punct("[") {
1877 self.advance();
1878 let prop = self.parse_expression()?;
1879 self.expect("]")?;
1880 expr = Expression::MemberExpression(MemberExpression {
1881 object: Box::new(expr),
1882 property: MemberProperty::Computed(Box::new(prop)),
1883 computed: true,
1884 });
1885 } else if self.at_punct("(") {
1886 let args = self.parse_arguments()?;
1887 expr = Expression::CallExpression(CallExpression {
1888 callee: Box::new(expr),
1889 arguments: args,
1890 });
1891 } else {
1892 break;
1893 }
1894 }
1895
1896 Ok(expr)
1897 }
1898
1899 fn parse_arguments(&mut self) -> Result<Vec<Argument>, String> {
1900 self.expect("(")?;
1901 let mut args = Vec::new();
1902 while !self.at_punct(")") && !self.is_eof() {
1903 if self.at_punct("...") {
1904 self.advance();
1905 args.push(Argument::Spread(self.parse_assignment_expression()?));
1906 } else {
1907 args.push(Argument::Expression(self.parse_assignment_expression()?));
1908 }
1909 if self.at_punct(",") {
1910 self.advance();
1911 }
1912 }
1913 self.expect(")")?;
1914 Ok(args)
1915 }
1916
1917 fn parse_primary(&mut self) -> Result<Expression, String> {
1918 if self.at_punct("(") {
1919 self.advance();
1920 let expr = self.parse_expression()?;
1921 self.expect(")")?;
1922 return Ok(expr);
1923 }
1924
1925 if self.at_keyword("new") {
1926 return self.parse_new_expression();
1927 }
1928
1929 if self.at_keyword("import") {
1930 if self.peek_at(".") {
1931 self.advance();
1932 self.expect(".")?;
1933 self.expect_keyword("meta")?;
1934 return Ok(Expression::MetaProperty(MetaProperty {
1935 meta: "import".to_string(),
1936 property: "meta".to_string(),
1937 }));
1938 }
1939 if self.peek_at("(") {
1940 self.advance();
1941 self.expect("(")?;
1942 let arg = self.parse_assignment_expression()?;
1943 self.expect(")")?;
1944
1945 return Ok(Expression::CallExpression(CallExpression {
1946 callee: Box::new(Expression::Identifier(Identifier {
1947 name: "import".to_string(),
1948 })),
1949 arguments: vec![Argument::Expression(arg)],
1950 }));
1951 }
1952 }
1953
1954 if self.cur_type() == Some(TokenType::Number) {
1955 let raw = self.cur_value().to_string();
1956 let lit = parse_number_literal(&raw);
1957 self.advance();
1958 return Ok(match lit {
1959 NumberLit::Normal(v) => Expression::Literal(Literal::Number(v)),
1960 NumberLit::LegacyOctal(v) => Expression::Literal(Literal::LegacyOctal(v)),
1961 });
1962 }
1963
1964 if self.cur_type() == Some(TokenType::BigInt) {
1965 let val = self.cur_value().to_string();
1966 self.advance();
1967 return Ok(Expression::Literal(Literal::BigInt(val)));
1968 }
1969
1970 if self.cur_type() == Some(TokenType::String) {
1971 let val = self.cur_value().to_string();
1972 self.advance();
1973 let has_escape = self.lexer.last_string_had_escape;
1974 return Ok(Expression::Literal(Literal::String(val, has_escape)));
1975 }
1976
1977 if self.at_keyword("true") {
1978 self.advance();
1979 return Ok(Expression::Literal(Literal::Boolean(true)));
1980 }
1981 if self.at_keyword("false") {
1982 self.advance();
1983 return Ok(Expression::Literal(Literal::Boolean(false)));
1984 }
1985 if self.at_keyword("null") {
1986 self.advance();
1987 return Ok(Expression::Literal(Literal::Null));
1988 }
1989 if self.at_keyword("undefined")
1990 || (self.cur_type() == Some(TokenType::Identifier) && self.cur_value() == "undefined")
1991 {
1992 self.advance();
1993 return Ok(Expression::Literal(Literal::Undefined));
1994 }
1995 if self.cur_type() == Some(TokenType::Identifier) && self.cur_value() == "NaN" {
1996 self.advance();
1997 return Ok(Expression::Literal(Literal::Number(f64::NAN)));
1998 }
1999 if self.cur_type() == Some(TokenType::Identifier) && self.cur_value() == "Infinity" {
2000 self.advance();
2001 return Ok(Expression::Literal(Literal::Number(f64::INFINITY)));
2002 }
2003 if self.at_keyword("this") {
2004 self.advance();
2005 return Ok(Expression::This);
2006 }
2007 if self.at_keyword("super") {
2008 self.advance();
2009 return Ok(Expression::Super);
2010 }
2011
2012 if self.cur_type() == Some(TokenType::Regex) {
2013 let val = self.cur_value().to_string();
2014 self.advance();
2015 let (pattern, flags) = parse_regex_value(&val);
2016 return Ok(Expression::RegExpLiteral(RegExpLiteral { pattern, flags }));
2017 }
2018
2019 if self.at_keyword("function") {
2020 self.advance();
2021 let generator = self.at_punct("*");
2022 if generator {
2023 self.advance();
2024 }
2025 return self.parse_function_expression(false, generator);
2026 }
2027
2028 if self.at_keyword("class") {
2029 return self.parse_class_expression();
2030 }
2031
2032 if self.at_punct("[") {
2033 return self.parse_array_expression();
2034 }
2035
2036 if self.at_punct("{") {
2037 return self.parse_object_expression();
2038 }
2039
2040 if self.at_template_start() {
2041 return self.parse_template_literal();
2042 }
2043
2044 if self.at_keyword("yield") {
2045 self.advance();
2046 let delegate = if self.at_punct("*") {
2047 self.advance();
2048 true
2049 } else {
2050 false
2051 };
2052 let argument =
2053 if self.is_eof() || self.at_punct(";") || self.at_punct("}") || self.at(")") {
2054 None
2055 } else {
2056 Some(Box::new(self.parse_assignment_expression()?))
2057 };
2058 return Ok(Expression::YieldExpression(YieldExpression {
2059 argument,
2060 delegate,
2061 }));
2062 }
2063
2064 if self.cur_type() == Some(TokenType::Identifier)
2065 || self.cur_type() == Some(TokenType::Keyword)
2066 {
2067 let name = self.cur_value().to_string();
2068 match name.as_str() {
2069 "NaN" => {
2070 self.advance();
2071 return Ok(Expression::Literal(Literal::Number(f64::NAN)));
2072 }
2073 "Infinity" => {
2074 self.advance();
2075 return Ok(Expression::Literal(Literal::Number(f64::INFINITY)));
2076 }
2077 _ => {
2078 self.advance();
2079 return Ok(Expression::Identifier(Identifier { name }));
2080 }
2081 }
2082 }
2083
2084 Err(self.error(&format!("Unexpected token: '{}'", self.cur_value())))
2085 }
2086
2087 fn parse_new_expression(&mut self) -> Result<Expression, String> {
2088 self.expect("new")?;
2089
2090 let callee = if self.at_keyword("new") {
2091 Box::new(self.parse_new_expression()?)
2092 } else {
2093 Box::new(self.parse_primary()?)
2094 };
2095
2096 let mut callee = callee;
2097 loop {
2098 if self.at_punct(".") {
2099 self.advance();
2100 let name = self.cur_value().to_string();
2101 self.advance();
2102 callee = Box::new(Expression::MemberExpression(MemberExpression {
2103 object: callee,
2104 property: MemberProperty::Identifier(name),
2105 computed: false,
2106 }));
2107 } else if self.at_punct("[") {
2108 self.advance();
2109 let prop = self.parse_expression()?;
2110 self.expect("]")?;
2111 callee = Box::new(Expression::MemberExpression(MemberExpression {
2112 object: callee,
2113 property: MemberProperty::Computed(Box::new(prop)),
2114 computed: true,
2115 }));
2116 } else {
2117 break;
2118 }
2119 }
2120
2121 let arguments = if self.at_punct("(") {
2122 self.parse_arguments()?
2123 } else {
2124 vec![]
2125 };
2126
2127 Ok(Expression::NewExpression(NewExpression {
2128 callee,
2129 arguments,
2130 }))
2131 }
2132
2133 fn parse_array_expression(&mut self) -> Result<Expression, String> {
2134 self.expect("[")?;
2135 let mut elements = Vec::new();
2136 while !self.at_punct("]") && !self.is_eof() {
2137 if self.at_punct(",") {
2138 elements.push(None);
2139 self.advance();
2140 continue;
2141 }
2142 if self.at_punct("...") {
2143 self.advance();
2144 elements.push(Some(ArrayElement::Spread(
2145 self.parse_assignment_expression()?,
2146 )));
2147 } else {
2148 elements.push(Some(ArrayElement::Expression(
2149 self.parse_assignment_expression()?,
2150 )));
2151 }
2152 if self.at_punct(",") {
2153 self.advance();
2154 }
2155 }
2156 self.expect("]")?;
2157 Ok(Expression::ArrayExpression(ArrayExpression { elements }))
2158 }
2159
2160 fn parse_object_expression(&mut self) -> Result<Expression, String> {
2161 self.expect("{")?;
2162 let mut properties = Vec::new();
2163 while !self.at_punct("}") && !self.is_eof() {
2164 if self.at_punct("...") {
2165 self.advance();
2166 properties.push(Property::SpreadElement(self.parse_assignment_expression()?));
2167 if self.at_punct(",") {
2168 self.advance();
2169 }
2170 continue;
2171 }
2172
2173 let mut is_async = false;
2174 if self.at_keyword("async")
2175 && !self.peek_at(";")
2176 && !self.peek_at(":")
2177 && !self.peek_at(",")
2178 && !self.peek_at("}")
2179 && !self.peek_at("=")
2180 {
2181 self.advance();
2182 is_async = true;
2183 }
2184
2185 let mut is_generator = false;
2186 if self.at_punct("*") {
2187 self.advance();
2188 is_generator = true;
2189 }
2190
2191 let (key, computed, shorthand) = self.parse_property_key()?;
2192
2193 if self.at_punct("(") && !shorthand {
2194 self.expect("(")?;
2195 let params = self.parse_parameter_list()?;
2196 self.expect(")")?;
2197 let body = self.parse_block_body()?;
2198 properties.push(Property::Property {
2199 key,
2200 value: Box::new(Expression::FunctionExpression(FunctionExpression {
2201 name: None,
2202 params,
2203 body,
2204 generator: is_generator,
2205 is_async,
2206 })),
2207 computed,
2208 shorthand: false,
2209 method: true,
2210 getter: false,
2211 setter: false,
2212 });
2213 if self.at_punct(",") {
2214 self.advance();
2215 }
2216 continue;
2217 }
2218
2219 if !computed {
2220 let accessor = match &key {
2221 PropertyKey::Identifier(name) if name == "get" || name == "set" => {
2222 Some(name.clone())
2223 }
2224 _ => None,
2225 };
2226
2227 if let Some(accessor_kind) = accessor {
2228 if self.at_punct(":") {
2229 } else {
2230 let (acc_key, _acc_computed, _acc_shorthand) = self.parse_property_key()?;
2231 if self.at_punct("(") {
2232 self.expect("(")?;
2233 let params = self.parse_parameter_list()?;
2234 self.expect(")")?;
2235 let body = self.parse_block_body()?;
2236
2237 if accessor_kind == "get" && !params.is_empty() {
2238 return Err(self.error("getter must not have parameters"));
2239 }
2240 if accessor_kind == "set" && params.len() != 1 {
2241 return Err(self.error("setter must have exactly one parameter"));
2242 }
2243
2244 let is_getter = accessor_kind == "get";
2245 properties.push(Property::Property {
2246 key: acc_key,
2247 value: Box::new(Expression::FunctionExpression(
2248 FunctionExpression {
2249 name: None,
2250 params,
2251 body,
2252 generator: false,
2253 is_async: false,
2254 },
2255 )),
2256 computed: false,
2257 shorthand: false,
2258 method: true,
2259 getter: is_getter,
2260 setter: !is_getter,
2261 });
2262
2263 if self.at_punct(",") {
2264 self.advance();
2265 }
2266 continue;
2267 }
2268 }
2269 }
2270 }
2271
2272 if self.at_punct(":") {
2273 self.advance();
2274 let value = self.parse_assignment_expression()?;
2275 properties.push(Property::Property {
2276 key,
2277 value: Box::new(value),
2278 computed,
2279 shorthand: false,
2280 method: false,
2281 getter: false,
2282 setter: false,
2283 });
2284 } else if shorthand {
2285 let name = match &key {
2286 PropertyKey::Identifier(n) => n.clone(),
2287 _ => return Err(self.error("invalid shorthand property")),
2288 };
2289 properties.push(Property::Property {
2290 key,
2291 value: Box::new(Expression::Identifier(Identifier { name })),
2292 computed: false,
2293 shorthand: true,
2294 method: false,
2295 getter: false,
2296 setter: false,
2297 });
2298 } else {
2299 return Err(self.error("expected ':' or '(' in object literal"));
2300 }
2301 if self.at_punct(",") {
2302 self.advance();
2303 }
2304 }
2305 self.expect("}")?;
2306 Ok(Expression::ObjectExpression(ObjectExpression {
2307 properties,
2308 }))
2309 }
2310
2311 fn parse_property_key(&mut self) -> Result<(PropertyKey, bool, bool), String> {
2312 if self.at_punct("[") {
2313 self.advance();
2314 let expr = self.parse_assignment_expression()?;
2315 self.expect("]")?;
2316 return Ok((PropertyKey::Computed(Box::new(expr)), true, false));
2317 }
2318 if self.cur_type() == Some(TokenType::PrivateIdentifier) {
2319 let name = self.cur_value().to_string();
2320 self.advance();
2321 return Ok((PropertyKey::PrivateIdentifier(name), false, false));
2322 }
2323 if self.cur_type() == Some(TokenType::String) {
2324 let val = self.cur_value().to_string();
2325 self.advance();
2326 let has_escape = self.lexer.last_string_had_escape;
2327 return Ok((
2328 PropertyKey::Literal(Literal::String(val, has_escape)),
2329 false,
2330 false,
2331 ));
2332 }
2333 if self.cur_type() == Some(TokenType::Number) {
2334 let raw = self.cur_value().to_string();
2335 let lit = parse_number_literal(&raw);
2336 self.advance();
2337 return Ok(match lit {
2338 NumberLit::Normal(v) => (PropertyKey::Literal(Literal::Number(v)), false, false),
2339 NumberLit::LegacyOctal(v) => {
2340 (PropertyKey::Literal(Literal::LegacyOctal(v)), false, false)
2341 }
2342 });
2343 }
2344 if self.is_identifier_name()
2345 || matches!(
2346 self.cur_value(),
2347 "true" | "false" | "null" | "undefined" | "NaN" | "Infinity"
2348 )
2349 {
2350 let name = self.cur_value().to_string();
2351 self.advance();
2352
2353 let shorthand = self.at_punct(":") || self.at_punct(",") || self.at_punct("}");
2354 return Ok((PropertyKey::Identifier(name), false, shorthand));
2355 }
2356 Err(self.error("expected property key"))
2357 }
2358
2359 fn parse_template_literal(&mut self) -> Result<Expression, String> {
2360 let mut quasis = Vec::new();
2361 let mut expressions = Vec::new();
2362
2363 let tok = self
2364 .current
2365 .take()
2366 .ok_or_else(|| self.error("Expected template literal"))?;
2367
2368 match tok.token_type {
2369 TokenType::NoSubstitutionTemplate => {
2370 quasis.push(TemplateElement {
2371 value: tok.value,
2372 tail: true,
2373 });
2374
2375 self.current = self.peek_token.take();
2376 self.saved_pos = self.lexer.pos;
2377 self.saved_line = self.lexer.line;
2378 self.saved_col = self.lexer.column;
2379 self.peek_token = self.lexer.next_token();
2380 return Ok(Expression::TemplateLiteral(TemplateLiteral {
2381 quasis,
2382 expressions,
2383 }));
2384 }
2385 TokenType::TemplateHead => {
2386 quasis.push(TemplateElement {
2387 value: tok.value,
2388 tail: false,
2389 });
2390
2391 self.current = self.peek_token.take();
2392 self.saved_pos = self.lexer.pos;
2393 self.saved_line = self.lexer.line;
2394 self.saved_col = self.lexer.column;
2395 self.peek_token = self.lexer.next_token();
2396 }
2397 _ => return Err(self.error("Expected template literal")),
2398 }
2399
2400 loop {
2401 let expr = self.parse_expression()?;
2402 expressions.push(expr);
2403
2404 if !self.at("}") {
2405 return Err(self.error("Expected '}' after template expression"));
2406 }
2407
2408 self.lexer.pos = self.saved_pos;
2409 self.lexer.line = self.saved_line;
2410 self.lexer.column = self.saved_col;
2411 self.peek_token = None;
2412
2413 let segment = self
2414 .lexer
2415 .scan_template_continuation()
2416 .ok_or_else(|| self.error("Unterminated template literal"))?;
2417
2418 match segment.token_type {
2419 TokenType::TemplateTail => {
2420 quasis.push(TemplateElement {
2421 value: segment.value,
2422 tail: true,
2423 });
2424
2425 self.current = self.lexer.next_token();
2426 self.saved_pos = self.lexer.pos;
2427 self.saved_line = self.lexer.line;
2428 self.saved_col = self.lexer.column;
2429 self.peek_token = self.lexer.next_token();
2430 break;
2431 }
2432 TokenType::TemplateMiddle => {
2433 quasis.push(TemplateElement {
2434 value: segment.value,
2435 tail: false,
2436 });
2437
2438 self.current = self.lexer.next_token();
2439 self.saved_pos = self.lexer.pos;
2440 self.saved_line = self.lexer.line;
2441 self.saved_col = self.lexer.column;
2442 self.peek_token = self.lexer.next_token();
2443 }
2444 _ => return Err(self.error("Unexpected token in template literal")),
2445 }
2446 }
2447
2448 Ok(Expression::TemplateLiteral(TemplateLiteral {
2449 quasis,
2450 expressions,
2451 }))
2452 }
2453}
2454
2455fn binding_to_target(bp: BindingPattern) -> AssignmentTarget {
2456 match bp {
2457 BindingPattern::Identifier(name) => AssignmentTarget::Identifier(name),
2458 BindingPattern::ArrayPattern(p) => AssignmentTarget::ArrayPattern(p),
2459 BindingPattern::ObjectPattern(p) => AssignmentTarget::ObjectPattern(p),
2460 BindingPattern::AssignmentPattern(p) => AssignmentTarget::AssignmentPattern(p),
2461 }
2462}
2463
2464fn expr_to_target(expr: Expression) -> Result<AssignmentTarget, String> {
2465 match expr {
2466 Expression::Identifier(id) => Ok(AssignmentTarget::Identifier(id.name)),
2467 Expression::MemberExpression(m) => Ok(AssignmentTarget::MemberExpression(m)),
2468 Expression::ArrayPattern(p) => Ok(AssignmentTarget::ArrayPattern(p)),
2469 Expression::ObjectPattern(p) => Ok(AssignmentTarget::ObjectPattern(p)),
2470 Expression::ArrayExpression(arr) => {
2471 let mut elements = Vec::new();
2472 for elem in arr.elements {
2473 match elem {
2474 Some(ArrayElement::Expression(e)) => {
2475 elements.push(Some(PatternElement::Pattern(expr_to_target(e)?)));
2476 }
2477 Some(ArrayElement::Spread(e)) => {
2478 elements.push(Some(PatternElement::RestElement(RestElement {
2479 argument: Box::new(expr_to_target(e)?),
2480 })));
2481 }
2482 None => {
2483 elements.push(None);
2484 }
2485 }
2486 }
2487 Ok(AssignmentTarget::ArrayPattern(ArrayPattern { elements }))
2488 }
2489 Expression::ObjectExpression(obj) => {
2490 let mut properties = Vec::new();
2491 for prop in obj.properties {
2492 match prop {
2493 Property::SpreadElement(arg) => {
2494 properties.push(ObjectPatternProperty::RestElement(RestElement {
2495 argument: Box::new(expr_to_target(arg)?),
2496 }));
2497 }
2498 Property::Property {
2499 key,
2500 value,
2501 computed,
2502 shorthand,
2503 ..
2504 } => {
2505 if shorthand {
2506 let name = match &key {
2507 PropertyKey::Identifier(n) => n.clone(),
2508 _ => {
2509 return Err(
2510 "invalid shorthand property in destructuring".to_string()
2511 );
2512 }
2513 };
2514 properties.push(ObjectPatternProperty::Property {
2515 key,
2516 value: AssignmentTarget::Identifier(name),
2517 computed: false,
2518 shorthand: true,
2519 });
2520 } else {
2521 let target = expr_to_target(*value)?;
2522 properties.push(ObjectPatternProperty::Property {
2523 key,
2524 value: target,
2525 computed,
2526 shorthand: false,
2527 });
2528 }
2529 }
2530 }
2531 }
2532 Ok(AssignmentTarget::ObjectPattern(ObjectPattern {
2533 properties,
2534 }))
2535 }
2536 Expression::AssignmentExpression(a) => {
2537 Ok(AssignmentTarget::AssignmentPattern(AssignmentPattern {
2538 left: Box::new(a.left),
2539 right: a.right,
2540 }))
2541 }
2542 _ => Err(format!("invalid assignment target: {:?}", expr)),
2543 }
2544}
2545
2546fn parse_regex_value(value: &str) -> (String, String) {
2547 if let Some(idx) = value.rfind('/') {
2548 let pattern = value[0..idx].to_string();
2549 let flags = value[idx + 1..].to_string();
2550 (pattern, flags)
2551 } else {
2552 (value.to_string(), String::new())
2553 }
2554}
2555
2556enum NumberLit {
2557 Normal(f64),
2558 LegacyOctal(i64),
2559}
2560
2561fn parse_number_literal(raw: &str) -> NumberLit {
2562 if raw.starts_with("0x") || raw.starts_with("0X") {
2563 let clean: String = raw[2..].chars().filter(|&c| c != '_').collect();
2564 NumberLit::Normal(
2565 i64::from_str_radix(&clean, 16)
2566 .map(|n| n as f64)
2567 .unwrap_or(0.0),
2568 )
2569 } else if raw.starts_with("0o") || raw.starts_with("0O") {
2570 let clean: String = raw[2..].chars().filter(|&c| c != '_').collect();
2571 NumberLit::Normal(
2572 i64::from_str_radix(&clean, 8)
2573 .map(|n| n as f64)
2574 .unwrap_or(0.0),
2575 )
2576 } else if raw.starts_with("0b") || raw.starts_with("0B") {
2577 let clean: String = raw[2..].chars().filter(|&c| c != '_').collect();
2578 NumberLit::Normal(
2579 i64::from_str_radix(&clean, 2)
2580 .map(|n| n as f64)
2581 .unwrap_or(0.0),
2582 )
2583 } else if raw.len() > 1 && raw.as_bytes()[0] == b'0' && raw.as_bytes()[1].is_ascii_digit() {
2584 let chars: Vec<char> = raw.chars().collect();
2585 if chars[1] == '8' || chars[1] == '9' {
2586 let clean: String = raw.chars().filter(|&c| c != '_').collect();
2587 NumberLit::Normal(clean.parse::<f64>().unwrap_or(0.0))
2588 } else if chars[1..]
2589 .iter()
2590 .all(|&c| c == '_' || (c.is_ascii_digit() && c <= '7'))
2591 {
2592 let clean: String = raw[1..].chars().filter(|&c| c != '_').collect();
2593 NumberLit::LegacyOctal(i64::from_str_radix(&clean, 8).unwrap_or(0))
2594 } else {
2595 let clean: String = raw.chars().filter(|&c| c != '_').collect();
2596 NumberLit::Normal(clean.parse::<f64>().unwrap_or(0.0))
2597 }
2598 } else {
2599 let clean: String = raw.chars().filter(|&c| c != '_').collect();
2600 NumberLit::Normal(clean.parse::<f64>().unwrap_or(0.0))
2601 }
2602}