refactor(transformer/typescript): remove unnecessary specific handling of TSModuledDeclaration transformation

Author: Dunqing

crates/oxc_syntax/src/symbol.rs

@@ -255,6 +255,11 @@ impl SymbolFlags {
         self.contains(Self::Ambient)
     }
 
+    #[inline]
+    pub fn is_namespace(&self) -> bool {
+        self.contains(Self::NameSpaceModule)
+    }
+
     /// If true, then the symbol can be referenced by a type reference
     #[inline]
     pub fn can_be_referenced_by_type(&self) -> bool {

crates/oxc_transformer/src/lib.rs

@@ -307,16 +307,6 @@ impl<'a> Traverse<'a> for TransformerImpl<'a, '_> {
         self.x2_es2022.exit_static_block(block, ctx);
     }
 
-    fn enter_ts_module_declaration(
-        &mut self,
-        decl: &mut TSModuleDeclaration<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        if let Some(typescript) = self.x0_typescript.as_mut() {
-            typescript.enter_ts_module_declaration(decl, ctx);
-        }
-    }
-
     #[inline]
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.common.enter_expression(expr, ctx);

crates/oxc_transformer/src/typescript/annotations.rs

@@ -1,5 +1,3 @@
-use rustc_hash::FxHashSet;
-
 use oxc_allocator::{TakeIn, Vec as ArenaVec};
 use oxc_ast::ast::*;
 use oxc_diagnostics::OxcDiagnostic;
@@ -29,7 +27,6 @@ pub struct TypeScriptAnnotations<'a, 'ctx> {
     has_jsx_fragment: bool,
     jsx_element_import_name: String,
     jsx_fragment_import_name: String,
-    type_identifier_names: FxHashSet<Atom<'a>>,
 }
 
 impl<'a, 'ctx> TypeScriptAnnotations<'a, 'ctx> {
@@ -55,7 +52,6 @@ impl<'a, 'ctx> TypeScriptAnnotations<'a, 'ctx> {
             has_jsx_fragment: false,
             jsx_element_import_name,
             jsx_fragment_import_name,
-            type_identifier_names: FxHashSet::default(),
         }
     }
 }
@@ -79,7 +75,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
                         true
                     } else {
                         decl.specifiers
-                            .retain(|specifier| self.can_retain_export_specifier(specifier, ctx));
+                            .retain(|specifier| Self::can_retain_export_specifier(specifier, ctx));
                         // Keep the export declaration if there are still specifiers after removing type exports
                         !decl.specifiers.is_empty()
                     }
@@ -456,8 +452,6 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
         // Remove TS specific statements
         stmts.retain(|stmt| match stmt {
             Statement::ExpressionStatement(s) => !s.expression.is_typescript_syntax(),
-            // Any namespaces left after namespace transform are type only, so remove them
-            Statement::TSModuleDeclaration(_) => false,
             match_declaration!(Statement) => !stmt.to_declaration().is_typescript_syntax(),
             // Ignore ModuleDeclaration as it's handled in the program
             _ => true,
@@ -548,17 +542,6 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
     fn enter_jsx_fragment(&mut self, _elem: &mut JSXFragment<'a>, _ctx: &mut TraverseCtx<'a>) {
         self.has_jsx_fragment = true;
     }
-
-    fn enter_ts_module_declaration(
-        &mut self,
-        decl: &mut TSModuleDeclaration<'a>,
-        _ctx: &mut TraverseCtx<'a>,
-    ) {
-        // NB: Namespace transform happens in `enter_program` visitor, and replaces retained
-        // namespaces with functions. This visitor is called after, by which time any remaining
-        // namespaces need to be deleted.
-        self.type_identifier_names.insert(decl.id.name());
-    }
 }
 
 impl<'a> TypeScriptAnnotations<'a, '_> {
@@ -615,14 +598,8 @@ impl<'a> TypeScriptAnnotations<'a, '_> {
         self.is_jsx_imports(&id.name)
     }
 
-    fn can_retain_export_specifier(
-        &self,
-        specifier: &ExportSpecifier<'a>,
-        ctx: &TraverseCtx<'a>,
-    ) -> bool {
-        if specifier.export_kind.is_type()
-            || self.type_identifier_names.contains(&specifier.exported.name())
-        {
+    fn can_retain_export_specifier(specifier: &ExportSpecifier<'a>, ctx: &TraverseCtx<'a>) -> bool {
+        if specifier.export_kind.is_type() {
             return false;
         }
         !matches!(&specifier.local, ModuleExportName::IdentifierReference(ident) if Self::is_refers_to_type(ident, ctx))

crates/oxc_transformer/src/typescript/mod.rs

@@ -118,14 +118,6 @@ impl<'a> Traverse<'a> for TypeScript<'a, '_> {
         self.annotations.enter_class_body(body, ctx);
     }
 
-    fn enter_ts_module_declaration(
-        &mut self,
-        decl: &mut TSModuleDeclaration<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        self.annotations.enter_ts_module_declaration(decl, ctx);
-    }
-
     fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.annotations.enter_expression(expr, ctx);
     }

crates/oxc_transformer/src/typescript/namespace.rs

@@ -1,7 +1,6 @@
 use oxc_allocator::{Box as ArenaBox, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_ecmascript::BoundNames;
-use oxc_semantic::Reference;
 use oxc_span::SPAN;
 use oxc_syntax::{
     operator::{AssignmentOperator, LogicalOperator},
@@ -22,24 +21,18 @@ pub struct TypeScriptNamespace<'a, 'ctx> {
 
     // Options
     allow_namespaces: bool,
-    only_remove_type_imports: bool,
 }
 
 impl<'a, 'ctx> TypeScriptNamespace<'a, 'ctx> {
     pub fn new(options: &TypeScriptOptions, ctx: &'ctx TransformCtx<'a>) -> Self {
-        Self {
-            ctx,
-            allow_namespaces: options.allow_namespaces,
-            only_remove_type_imports: options.only_remove_type_imports,
-        }
+        Self { ctx, allow_namespaces: options.allow_namespaces }
     }
 }
 
 impl<'a> Traverse<'a> for TypeScriptNamespace<'a, '_> {
     // `namespace Foo { }` -> `let Foo; (function (_Foo) { })(Foo || (Foo = {}));`
     fn enter_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
         // namespace declaration is only allowed at the top level
-
         if !has_namespace(program.body.as_slice()) {
             return;
         }
@@ -59,14 +52,12 @@ impl<'a> Traverse<'a> for TypeScriptNamespace<'a, '_> {
                     self.handle_nested(decl, /* is_export */ false, &mut new_stmts, None, ctx);
                     continue;
                 }
-                Statement::ExportNamedDeclaration(export_decl) => {
-                    if export_decl.declaration.as_ref().is_none_or(|decl| {
-                        decl.declare() || !matches!(decl, Declaration::TSModuleDeclaration(_))
-                    }) {
-                        new_stmts.push(Statement::ExportNamedDeclaration(export_decl));
-                        continue;
-                    }
-
+                Statement::ExportNamedDeclaration(export_decl)
+                    if export_decl.declaration.as_ref().is_some_and(|declaration| {
+                        !declaration.declare()
+                            && matches!(declaration, Declaration::TSModuleDeclaration(_))
+                    }) =>
+                {
                     let Some(Declaration::TSModuleDeclaration(decl)) =
                         export_decl.unbox().declaration
                     else {
@@ -111,6 +102,11 @@ impl<'a> TypeScriptNamespace<'a, '_> {
             return;
         };
 
+        // Empty namespace or only have type declarations.
+        if ctx.scoping().symbol_flags(ident.symbol_id()).is_namespace() {
+            return;
+        }
+
         let Some(body) = body else {
             return;
         };
@@ -151,7 +147,6 @@ impl<'a> TypeScriptNamespace<'a, '_> {
             match stmt {
                 Statement::TSModuleDeclaration(decl) => {
                     self.handle_nested(decl, /* is_export */ false, &mut new_stmts, None, ctx);
-                    continue;
                 }
                 Statement::ExportNamedDeclaration(export_decl) => {
                     // NB: `ExportNamedDeclaration` with no declaration (e.g. `export {x}`) is not
@@ -214,33 +209,9 @@ impl<'a> TypeScriptNamespace<'a, '_> {
                             _ => {}
                         }
                     }
-                    continue;
                 }
-                // Retain when `only_remove_type_imports` is true or there are value references
-                // The behavior is the same as `TypeScriptModule::transform_ts_import_equals`
-                Statement::TSImportEqualsDeclaration(decl)
-                    if !self.only_remove_type_imports
-                        && ctx
-                            .scoping()
-                            .get_resolved_references(decl.id.symbol_id())
-                            .all(Reference::is_type) =>
-                {
-                    continue;
-                }
-                Statement::TSTypeAliasDeclaration(_) | Statement::TSInterfaceDeclaration(_) => {
-                    continue;
-                }
-                _ => {}
+                _ => new_stmts.push(stmt),
             }
-            new_stmts.push(stmt);
-        }
-
-        if new_stmts.is_empty() {
-            // Delete the scope binding that `ctx.generate_uid` created above,
-            // as no binding is actually being created
-            ctx.scoping_mut().remove_binding(scope_id, uid_binding.name.as_str());
-
-            return;
         }
 
         if !Self::is_redeclaration_namespace(&ident, ctx) {