fix(es/parser): Parser a program as a module with TLA in non-expression statement (#10287)

fixes: #10109

1. Lift `top_level` flag to parser context
2. Add checks before parsing `await` in unary expr.

Author: CPunisher

.changeset/honest-sloths-flash.md

@@ -0,0 +1,5 @@
+---
+swc_ecma_parser: major
+---
+
+fix(parser): parse program as module with TLA in non-expression statement

crates/swc_ecma_parser/src/lib.rs

@@ -432,6 +432,8 @@ pub struct Context {
     disallow_conditional_types: bool,
 
     allow_using_decl: bool,
+
+    top_level: bool,
 }
 
 #[derive(Debug, Clone, Copy, Default)]

crates/swc_ecma_parser/src/parser/class_and_fn.rs

@@ -1417,6 +1417,7 @@ impl<I: Tokens> Parser<I> {
             in_static_block: false,
             is_break_allowed: false,
             is_continue_allowed: false,
+            top_level: false,
             ..self.ctx()
         };
         let state = State {

crates/swc_ecma_parser/src/parser/expr/ops.rs

@@ -397,6 +397,14 @@ impl<I: Tokens> Parser<I> {
             return Ok(Ident::new_no_ctxt("await".into(), span).into());
         }
 
+        // This has been checked if start_of_await_token == true,
+        if start_of_await_token.is_none() && ctx.top_level {
+            self.state.found_module_item = true;
+            if !ctx.can_be_module {
+                self.emit_err(await_token, SyntaxError::TopLevelAwaitInScript);
+            }
+        }
+
         if ctx.in_function && !ctx.in_async {
             self.emit_err(await_token, SyntaxError::AwaitInFunction);
         }

crates/swc_ecma_parser/src/parser/expr/tests.rs

@@ -27,7 +27,7 @@ fn member_expr(s: &'static str) -> Box<Expr> {
 
 fn expr(s: &'static str) -> Box<Expr> {
     test_parser(s, syntax(), |p| {
-        p.parse_stmt(true).map(|stmt| match stmt {
+        p.parse_stmt().map(|stmt| match stmt {
             Stmt::Expr(expr) => expr.expr,
             _ => unreachable!(),
         })
@@ -368,7 +368,7 @@ fn issue_319_1() {
 fn issue_328() {
     assert_eq_ignore_span!(
         test_parser("import('test')", Syntax::Es(Default::default()), |p| {
-            p.parse_stmt(true)
+            p.parse_stmt()
         }),
         Stmt::Expr(ExprStmt {
             span,

crates/swc_ecma_parser/src/parser/mod.rs

@@ -77,6 +77,7 @@ impl<I: Tokens> Parser<I> {
         let in_declare = false;
         let ctx = Context {
             in_declare,
+            top_level: true,
             ..input.ctx()
         };
         input.set_ctx(ctx);
@@ -100,6 +101,7 @@ impl<I: Tokens> Parser<I> {
 
         let ctx = Context {
             module: false,
+            top_level: true,
             ..self.ctx()
         };
         self.set_ctx(ctx);
@@ -108,7 +110,7 @@ impl<I: Tokens> Parser<I> {
 
         let shebang = self.parse_shebang()?;
 
-        self.parse_block_body(true, true, None).map(|body| Script {
+        self.parse_block_body(true, None).map(|body| Script {
             span: span!(self, start),
             body,
             shebang,
@@ -124,6 +126,7 @@ impl<I: Tokens> Parser<I> {
         let ctx = Context {
             module: true,
             strict: false,
+            top_level: true,
             ..self.ctx()
         };
         // Module code is always in strict mode
@@ -132,7 +135,7 @@ impl<I: Tokens> Parser<I> {
         let start = cur_pos!(self);
         let shebang = self.parse_shebang()?;
 
-        self.parse_block_body(true, true, None).map(|body| Module {
+        self.parse_block_body(true, None).map(|body| Module {
             span: span!(self, start),
             body,
             shebang,
@@ -149,10 +152,11 @@ impl<I: Tokens> Parser<I> {
         let shebang = self.parse_shebang()?;
         let ctx = Context {
             can_be_module: true,
+            top_level: true,
             ..self.ctx()
         };
 
-        let body: Vec<ModuleItem> = self.with_ctx(ctx).parse_block_body(true, true, None)?;
+        let body: Vec<ModuleItem> = self.with_ctx(ctx).parse_block_body(true, None)?;
         let has_module_item = self.state.found_module_item
             || body
                 .iter()
@@ -162,6 +166,7 @@ impl<I: Tokens> Parser<I> {
                 module: true,
                 can_be_module: true,
                 strict: true,
+                top_level: true,
                 ..self.ctx()
             };
             // Emit buffered strict mode / module code violations
@@ -195,6 +200,7 @@ impl<I: Tokens> Parser<I> {
             module: true,
             can_be_module: true,
             strict: true,
+            top_level: true,
             ..self.ctx()
         };
         // Module code is always in strict mode
@@ -203,7 +209,7 @@ impl<I: Tokens> Parser<I> {
         let start = cur_pos!(self);
         let shebang = self.parse_shebang()?;
 
-        self.parse_block_body(true, true, None).map(|body| Module {
+        self.parse_block_body(true, None).map(|body| Module {
             span: span!(self, start),
             body,
             shebang,