@@ -0,0 +1,7 @@
+---
+swc_core: patch
+swc_ecma_parser: patch
+swc_ecma_transforms_base: patch
+---
+
+fix(es/parser): Parse ambiguous top-level `await` expressions using the valid Program goal
@@ -1,3 +1,5 @@
-await (()=>{
+await(()=>{
     console.log("non-IIFE");
-}), await void console.log("IIFE");
+}), await(()=>{
+    console.log("IIFE");
+})();
@@ -1,8 +1 @@
-var async = (x)=>{
-    console.log("async", x);
-};
-var await = (x)=>{
-    console.log("await", x);
-};
-async(1);
-await 2;
+var async=x=>{console.log("async",x)};var await=x=>{console.log("await",x)};async(1);await(2);
@@ -1,8 +1,8 @@
 var o = function(o) {
     console.log("async", o);
 };
-var a = function(o) {
+var n = function(o) {
     console.log("await", o);
 };
 o(1);
-await 2;
+n(2);
@@ -1,8 +1 @@
-var async = function(x) {
-    console.log("async", x);
-};
-var await = function(x) {
-    console.log("await", x);
-};
-async(1);
-await 2;
+var async=function(x){console.log("async",x)};var await=function(x){console.log("await",x)};async(1);await(2);
@@ -1,8 +1,8 @@
 var o = function(o) {
     console.log("async", o);
 };
-var a = function(o) {
+var n = function(o) {
     console.log("await", o);
 };
 o(1);
-await (2);
+n(2);
@@ -133,10 +133,30 @@ impl<I: Tokens> Tokens for Capturing<I> {
         self.inner.take_errors()
     }
 
+    fn has_errors(&self) -> bool {
+        self.inner.has_errors()
+    }
+
+    fn diagnostic_checkpoint_save(&self) -> (usize, usize) {
+        self.inner.diagnostic_checkpoint_save()
+    }
+
+    fn diagnostic_checkpoint_load(&mut self, checkpoint: (usize, usize)) {
+        self.inner.diagnostic_checkpoint_load(checkpoint);
+    }
+
     fn take_script_module_errors(&mut self) -> Vec<Error> {
         self.inner.take_script_module_errors()
     }
 
+    fn set_defer_comments(&mut self, defer: bool) {
+        self.inner.set_defer_comments(defer);
+    }
+
+    fn finalize_comments(&mut self) {
+        self.inner.finalize_comments();
+    }
+
     fn update_token_flags(&mut self, f: impl FnOnce(&mut TokenFlags)) {
         self.inner.update_token_flags(f);
     }
 
@@ -208,6 +208,8 @@ pub struct Lexer<'a> {
     comments: Option<&'a dyn Comments>,
     /// [Some] if comment comment parsing is enabled. Otherwise [None]
     comments_buffer: Option<CommentsBuffer>,
+    /// Whether comments should remain buffered while the parser may rewind.
+    defer_comments: bool,
 
     pub ctx: Context,
     input: StringInput<'a>,
@@ -312,6 +314,7 @@ impl<'a> Lexer<'a> {
         Lexer {
             comments,
             comments_buffer: comments.is_some().then(CommentsBuffer::new),
+            defer_comments: false,
             ctx: Default::default(),
             input,
             start_pos,
@@ -1337,6 +1340,7 @@ impl<'a> Lexer<'a> {
         if let Some(comments) = self.comments() {
             let last = self.state.prev_hi;
             let start_pos = self.start_pos();
+            let defer_comments = self.defer_comments;
             let comments_buffer = self.comments_buffer_mut().unwrap();
 
             // if the file had no tokens and no shebang, then treat any
@@ -1350,6 +1354,10 @@ impl<'a> Lexer<'a> {
             // move the pending to the leading or trailing
             comments_buffer.pending_to_comment(kind, last);
 
+            if defer_comments {
+                return;
+            }
+
             // now fill the user's passed in comments
             for comment in comments_buffer.take_comments() {
                 match comment.kind {
@@ -1364,6 +1372,28 @@ impl<'a> Lexer<'a> {
         }
     }
 
+    fn finalize_comments(&mut self) {
+        self.defer_comments = false;
+
+        let Some(comments) = self.comments() else {
+            return;
+        };
+        let Some(comments_buffer) = self.comments_buffer.as_mut() else {
+            return;
+        };
+
+        for comment in comments_buffer.take_comments() {
+            match comment.kind {
+                BufferedCommentKind::Leading => {
+                    comments.add_leading(comment.pos, comment.comment);
+                }
+                BufferedCommentKind::Trailing => {
+                    comments.add_trailing(comment.pos, comment.comment);
+                }
+            }
+        }
+    }
+
     fn read_jsx_entity(&mut self) -> LexResult<(Wtf8Atom, String)> {
         debug_assert!(self.syntax().jsx());
 
 
@@ -144,11 +144,37 @@ impl crate::input::Tokens for Lexer<'_> {
         errors
     }
 
+    #[inline]
+    fn has_errors(&self) -> bool {
+        !self.errors.is_empty()
+    }
+
+    #[inline]
+    fn diagnostic_checkpoint_save(&self) -> (usize, usize) {
+        (self.errors.len(), self.module_errors.len())
+    }
+
+    #[inline]
+    fn diagnostic_checkpoint_load(&mut self, checkpoint: (usize, usize)) {
+        self.errors.truncate(checkpoint.0);
+        self.module_errors.truncate(checkpoint.1);
+    }
+
     #[inline]
     fn take_script_module_errors(&mut self) -> Vec<Error> {
         take(&mut self.module_errors)
     }
 
+    #[inline]
+    fn set_defer_comments(&mut self, defer: bool) {
+        self.defer_comments = defer;
+    }
+
+    #[inline]
+    fn finalize_comments(&mut self) {
+        Lexer::finalize_comments(self);
+    }
+
     #[inline]
     fn end_pos(&self) -> BytePos {
         self.input.end_pos()
 
@@ -375,13 +375,15 @@ impl<I: Tokens> Parser<I> {
                 }
             };
 
-            let (this_param, params) = p.do_inside_of_context(Context::InParameters, |p| {
-                p.do_outside_of_context(Context::InFunction, |p| {
-                    if is_async {
-                        p.do_inside_of_context(Context::InAsync, parse_args_with_generator_ctx)
-                    } else {
-                        p.do_outside_of_context(Context::InAsync, parse_args_with_generator_ctx)
-                    }
+            let (this_param, params) = p.without_async_arrow_param_await_collection(|p| {
+                p.do_inside_of_context(Context::InParameters, |p| {
+                    p.do_outside_of_context(Context::InFunction, |p| {
+                        if is_async {
+                            p.do_inside_of_context(Context::InAsync, parse_args_with_generator_ctx)
+                        } else {
+                            p.do_outside_of_context(Context::InAsync, parse_args_with_generator_ctx)
+                        }
+                    })
                 })
             })?;
 
@@ -888,12 +890,18 @@ impl<I: Tokens> Parser<I> {
         let type_ann = self.try_parse_ts_type_ann()?;
 
         self.do_inside_of_context(Context::IncludeInExpr.union(Context::InClassField), |p| {
-            let value = if p.input().is(Token::Eq) {
-                p.assert_and_bump(Token::Eq);
-                Some(p.parse_assignment_expr()?)
-            } else {
-                None
-            };
+            // Class field initializers have their own Await grammar parameter and must
+            // not inherit the unambiguous Program probe's top-level async context.
+            let value = p.without_async_arrow_param_await_collection(|p| {
+                p.do_outside_of_context(Context::InAsync, |p| {
+                    if p.input().is(Token::Eq) {
+                        p.assert_and_bump(Token::Eq);
+                        p.parse_assignment_expr().map(Some)
+                    } else {
+                        Ok(None)
+                    }
+                })
+            })?;
 
             if declare && value.is_some() {
                 p.emit_err(p.span(start), SyntaxError::TS1183);