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