fix(es/parser): Make export in NS to not affect file type (#10799)

bvanjoi · web-flow · commit ae22033dc4d0 · 2025-07-08T17:48:57.000+09:00
Fixes #10797
diff --git a/.changeset/olive-carrots-work.md b/.changeset/olive-carrots-work.md
@@ -0,0 +1,7 @@
+---
+swc_ecma_lexer: patch
+swc_ecma_parser: patch
+swc_core: patch
+---
+
+fix(es/parser): export in ns not affect file type
diff --git a/crates/swc_ecma_lexer/src/common/context.rs b/crates/swc_ecma_lexer/src/common/context.rs
@@ -65,5 +65,7 @@ bitflags::bitflags! {
       const AllowUsingDecl = 1 << 28;
 
       const TopLevel = 1 << 29;
+
+      const TsModuleBlock = 1 << 30;
   }
 }
diff --git a/crates/swc_ecma_lexer/src/common/parser/module_item.rs b/crates/swc_ecma_lexer/src/common/parser/module_item.rs
@@ -33,7 +33,10 @@ fn handle_import_export<'a, P: Parser<'a>>(
     p: &mut P,
     decorators: Vec<Decorator>,
 ) -> PResult<ModuleItem> {
-    if !p.ctx().contains(Context::TopLevel) {
+    if !p
+        .ctx()
+        .intersects(Context::TopLevel.union(Context::TsModuleBlock))
+    {
         syntax_error!(p, SyntaxError::NonTopLevelImportExport);
     }
 
@@ -343,7 +346,7 @@ fn parse_export<'a, P: Parser<'a>>(
     p: &mut P,
     mut decorators: Vec<Decorator>,
 ) -> PResult<ModuleDecl> {
-    if !p.ctx().contains(Context::Module) {
+    if !p.ctx().contains(Context::Module) && p.ctx().contains(Context::TopLevel) {
         // Switch to module mode
         let ctx = p.ctx() | Context::Module | Context::Strict;
         p.set_ctx(ctx);
diff --git a/crates/swc_ecma_lexer/src/common/parser/stmt.rs b/crates/swc_ecma_lexer/src/common/parser/stmt.rs
@@ -1384,53 +1384,61 @@ pub fn parse_stmt_block_body<'a, P: Parser<'a>>(
 
 pub(super) fn parse_block_body<'a, P: Parser<'a>, Type: IsDirective + From<Stmt>>(
     p: &mut P,
-    mut allow_directives: bool,
+    allow_directives: bool,
     end: Option<&P::Token>,
     handle_import_export: impl Fn(&mut P, Vec<Decorator>) -> PResult<Type>,
 ) -> PResult<Vec<Type>> {
     trace_cur!(p, parse_block_body);
 
-    let old_ctx = p.ctx();
-
     let mut stmts = Vec::with_capacity(8);
-    while {
-        match (p.input_mut().cur(), end) {
-            (Some(cur), Some(end)) => cur != end,
-            (Some(_), None) => true,
-            (None, None) => false,
-            (None, Some(_)) => {
-                let eof_text = p.input_mut().dump_cur();
-                p.emit_err(
-                    p.input().cur_span(),
-                    SyntaxError::Expected(format!("{:?}", end.unwrap()), eof_text),
-                );
-                false
-            }
+
+    let is_stmt_start = |p: &mut P| match (p.input_mut().cur(), end) {
+        (Some(cur), Some(end)) => cur != end,
+        (Some(_), None) => true,
+        (None, None) => false,
+        (None, Some(_)) => {
+            let eof_text = p.input_mut().dump_cur();
+            p.emit_err(
+                p.input().cur_span(),
+                SyntaxError::Expected(format!("{:?}", end.unwrap()), eof_text),
+            );
+            false
         }
-    } {
+    };
+
+    let mut has_strict_directive = false;
+    if is_stmt_start(p) {
         let stmt = parse_stmt_like(p, true, &handle_import_export)?;
-        if allow_directives {
-            allow_directives = false;
-            if stmt.is_use_strict() {
-                p.set_ctx(old_ctx | Context::Strict);
-                if p.input().knows_cur() && !p.is_general_semi() {
-                    unreachable!(
-                        "'use strict'; directive requires parser.input.cur to be empty or '}}', \
-                         but current token was: {:?}",
-                        p.input_mut().cur()
-                    )
-                }
+        if allow_directives && stmt.is_use_strict() {
+            has_strict_directive = true;
+            if p.input().knows_cur() && !p.is_general_semi() {
+                unreachable!(
+                    "'use strict'; directive requires parser.input.cur to be empty or '}}', but \
+                     current token was: {:?}",
+                    p.input_mut().cur()
+                )
             }
         }
-
         stmts.push(stmt);
     }
 
+    let parse_rest_stmts = |p: &mut P, stmts: &mut Vec<Type>| -> PResult<()> {
+        while is_stmt_start(p) {
+            let stmt = parse_stmt_like(p, true, &handle_import_export)?;
+            stmts.push(stmt);
+        }
+        Ok(())
+    };
+
+    if has_strict_directive {
+        p.do_inside_of_context(Context::Strict, |p| parse_rest_stmts(p, &mut stmts))?;
+    } else {
+        parse_rest_stmts(p, &mut stmts)?;
+    };
+
     if p.input_mut().cur().is_some() && end.is_some() {
         p.bump();
     }
 
-    p.set_ctx(old_ctx);
-
     Ok(stmts)
 }
diff --git a/crates/swc_ecma_lexer/src/common/parser/typescript.rs b/crates/swc_ecma_lexer/src/common/parser/typescript.rs
@@ -2345,10 +2345,10 @@ fn parse_ts_module_block<'a, P: Parser<'a>>(p: &mut P) -> PResult<TsModuleBlock>
 
     let start = p.cur_pos();
     expect!(p, &P::Token::LBRACE);
-    // Inside of a module block is considered "top-level", meaning it can have
-    // imports and exports.
-    let body = p.do_inside_of_context(Context::TopLevel, |p| {
-        parse_module_item_block_body(p, false, Some(&P::Token::RBRACE))
+    let body = p.do_inside_of_context(Context::TsModuleBlock, |p| {
+        p.do_outside_of_context(Context::TopLevel, |p| {
+            parse_module_item_block_body(p, false, Some(&P::Token::RBRACE))
+        })
     })?;
 
     Ok(TsModuleBlock {
diff --git a/crates/swc_ecma_parser/src/parser/stmt.rs b/crates/swc_ecma_parser/src/parser/stmt.rs
@@ -28,7 +28,7 @@ impl<I: Tokens> Parser<I> {
 mod tests {
     use swc_atoms::atom;
     use swc_common::{comments::SingleThreadedComments, DUMMY_SP as span};
-    use swc_ecma_lexer::common::parser::stmt::TempForHead;
+    use swc_ecma_lexer::{common::parser::stmt::TempForHead, TsSyntax};
     use swc_ecma_visit::assert_eq_ignore_span;
 
     use super::*;
@@ -1181,4 +1181,30 @@ const foo;"#;
 
         test_parser(src, Default::default(), |p| p.parse_script());
     }
+
+    #[test]
+    fn issue_10797_0() {
+        let src = "
+var b = delete ANY1;
+
+module A {
+    export const a = 1
+}";
+        test_parser(src, Syntax::Typescript(TsSyntax::default()), |p| {
+            p.parse_script()
+        });
+    }
+
+    #[test]
+    fn issue_10797_1() {
+        let src = "
+module A {
+    export const a = 1
+}
+
+var b = delete ANY1;";
+        test_parser(src, Syntax::Typescript(TsSyntax::default()), |p| {
+            p.parse_script()
+        });
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -65,5 +65,7 @@ bitflags::bitflags! {`
`65`	`65`	`const AllowUsingDecl = 1 << 28;`
`66`	`66`
`67`	`67`	`const TopLevel = 1 << 29;`
	`68`	`+`
	`69`	`+ const TsModuleBlock = 1 << 30;`
`68`	`70`	`}`
`69`	`71`	`}`