feat(mangler): mangle private class members

Author: sapphi-red

crates/oxc/src/compiler.rs

@@ -5,7 +5,7 @@ use oxc_ast::ast::Program;
 use oxc_codegen::{Codegen, CodegenOptions, CodegenReturn};
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_isolated_declarations::{IsolatedDeclarations, IsolatedDeclarationsOptions};
-use oxc_mangler::{MangleOptions, Mangler};
+use oxc_mangler::{MangleOptions, Mangler, ManglerReturn};
 use oxc_minifier::{CompressOptions, Compressor};
 use oxc_parser::{ParseOptions, Parser, ParserReturn};
 use oxc_semantic::{Scoping, SemanticBuilder, SemanticBuilderReturn};
@@ -282,21 +282,28 @@ pub trait CompilerInterface {
         Compressor::new(allocator).build(program, options);
     }
 
-    fn mangle(&self, program: &mut Program<'_>, options: MangleOptions) -> Scoping {
+    fn mangle(&self, program: &mut Program<'_>, options: MangleOptions) -> ManglerReturn {
         Mangler::new().with_options(options).build(program)
     }
 
     fn codegen(
         &self,
         program: &Program<'_>,
         source_path: &Path,
-        scoping: Option<Scoping>,
+        mangler_return: Option<ManglerReturn>,
         options: CodegenOptions,
     ) -> CodegenReturn {
         let mut options = options;
         if self.enable_sourcemap() {
             options.source_map_path = Some(source_path.to_path_buf());
         }
-        Codegen::new().with_options(options).with_scoping(scoping).build(program)
+        let (scoping, class_private_mappings) = mangler_return
+            .map(|m| (Some(m.scoping), Some(m.class_private_mappings)))
+            .unwrap_or_default();
+        Codegen::new()
+            .with_options(options)
+            .with_scoping(scoping)
+            .with_private_member_mappings(class_private_mappings)
+            .build(program)
     }
 }

crates/oxc_codegen/src/gen.rs

@@ -2264,6 +2264,7 @@ impl Gen for Class<'_> {
         let n = p.code_len();
         let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n);
         p.wrap(wrap, |p| {
+            p.enter_class();
             p.print_decorators(&self.decorators, ctx);
             p.print_space_before_identifier();
             p.add_source_mapping(self.span);
@@ -2295,6 +2296,7 @@ impl Gen for Class<'_> {
             p.print_soft_space();
             self.body.print(p, ctx);
             p.needs_semicolon = false;
+            p.exit_class();
         });
     }
 }
@@ -2747,9 +2749,20 @@ impl Gen for AccessorProperty<'_> {
 
 impl Gen for PrivateIdentifier<'_> {
     fn r#gen(&self, p: &mut Codegen, _ctx: Context) {
+        let name = if let Some(class_index) = p.current_class_index()
+            && let Some(mangled) = &p
+                .private_member_mappings
+                .as_ref()
+                .and_then(|m| m[class_index].get(self.name.as_str()))
+        {
+            (*mangled).clone()
+        } else {
+            self.name.into_compact_str()
+        };
+
         p.print_ascii_byte(b'#');
         p.add_source_mapping_for_name(self.span, &self.name);
-        p.print_str(self.name.as_str());
+        p.print_str(name.as_str());
     }
 }
 

crates/oxc_codegen/src/lib.rs

@@ -12,12 +12,13 @@ use cow_utils::CowUtils;
 use oxc_ast::ast::*;
 use oxc_data_structures::{code_buffer::CodeBuffer, stack::Stack};
 use oxc_semantic::Scoping;
-use oxc_span::{GetSpan, Span};
+use oxc_span::{CompactStr, GetSpan, Span};
 use oxc_syntax::{
     identifier::{is_identifier_part, is_identifier_part_ascii},
     operator::{BinaryOperator, UnaryOperator, UpdateOperator},
     precedence::Precedence,
 };
+use rustc_hash::FxHashMap;
 
 mod binary_expr_visitor;
 mod comment;
@@ -82,6 +83,9 @@ pub struct Codegen<'a> {
 
     scoping: Option<Scoping>,
 
+    /// Private member name mappings for mangling
+    private_member_mappings: Option<Vec<FxHashMap<String, CompactStr>>>,
+
     /// Output Code
     code: CodeBuffer,
 
@@ -91,6 +95,7 @@ pub struct Codegen<'a> {
     need_space_before_dot: usize,
     print_next_indent_as_space: bool,
     binary_expr_stack: Stack<BinaryExpressionVisitor<'a>>,
+    class_stack_pos: usize,
     /// Indicates the output is JSX type, it is set in [`Program::gen`] and the result
     /// is obtained by [`oxc_span::SourceType::is_jsx`]
     is_jsx: bool,
@@ -146,11 +151,13 @@ impl<'a> Codegen<'a> {
             options,
             source_text: None,
             scoping: None,
+            private_member_mappings: None,
             code: CodeBuffer::default(),
             needs_semicolon: false,
             need_space_before_dot: 0,
             print_next_indent_as_space: false,
             binary_expr_stack: Stack::with_capacity(12),
+            class_stack_pos: 0,
             prev_op_end: 0,
             prev_reg_exp_end: 0,
             prev_op: None,
@@ -190,6 +197,19 @@ impl<'a> Codegen<'a> {
         self
     }
 
+    /// Set private member name mappings for mangling.
+    ///
+    /// This allows renaming of private class members like `#field` -> `#a`.
+    /// The Vec contains per-class mappings, indexed by class declaration order.
+    #[must_use]
+    pub fn with_private_member_mappings(
+        mut self,
+        mappings: Option<Vec<FxHashMap<String, CompactStr>>>,
+    ) -> Self {
+        self.private_member_mappings = mappings;
+        self
+    }
+
     /// Print a [`Program`] into a string of source code.
     ///
     /// A source map will be generated if [`CodegenOptions::source_map_path`] is set.
@@ -445,6 +465,21 @@ impl<'a> Codegen<'a> {
         }
     }
 
+    #[inline]
+    fn enter_class(&mut self) {
+        self.class_stack_pos += 1;
+    }
+
+    #[inline]
+    fn exit_class(&mut self) {
+        self.class_stack_pos -= 1;
+    }
+
+    #[inline]
+    fn current_class_index(&self) -> Option<usize> {
+        if self.class_stack_pos > 0 { Some(self.class_stack_pos - 1) } else { None }
+    }
+
     #[inline]
     fn wrap<F: FnMut(&mut Self)>(&mut self, wrap: bool, mut f: F) {
         if wrap {

crates/oxc_mangler/src/lib.rs

@@ -2,15 +2,15 @@ use std::iter::{self, repeat_with};
 
 use itertools::Itertools;
 use keep_names::collect_name_symbols;
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use base54::base54;
 use oxc_allocator::{Allocator, BitSet, Vec};
 use oxc_ast::ast::{Declaration, Program, Statement};
 use oxc_data_structures::inline_string::InlineString;
 use oxc_index::Idx;
 use oxc_semantic::{AstNodes, Scoping, Semantic, SemanticBuilder, SymbolId};
-use oxc_span::Atom;
+use oxc_span::{Atom, CompactStr};
 
 pub(crate) mod base54;
 mod keep_names;
@@ -56,6 +56,13 @@ impl TempAllocator<'_> {
     }
 }
 
+pub struct ManglerReturn {
+    pub scoping: Scoping,
+    /// A vector where each element corresponds to a class in declaration order.
+    /// Each element is a mapping from original private member names to their mangled names.
+    pub class_private_mappings: std::vec::Vec<FxHashMap<String, CompactStr>>,
+}
+
 /// # Name Mangler / Symbol Minification
 ///
 /// ## Example
@@ -257,11 +264,12 @@ impl<'t> Mangler<'t> {
     /// Mangles the program. The resulting SymbolTable contains the mangled symbols - `program` is not modified.
     /// Pass the symbol table to oxc_codegen to generate the mangled code.
     #[must_use]
-    pub fn build(self, program: &Program<'_>) -> Scoping {
+    pub fn build(self, program: &Program<'_>) -> ManglerReturn {
         let mut semantic =
             SemanticBuilder::new().with_scope_tree_child_ids(true).build(program).semantic;
+        let class_private_mappings = Self::collect_private_members_from_semantic(&semantic);
         self.build_with_semantic(&mut semantic, program);
-        semantic.into_scoping()
+        ManglerReturn { scoping: semantic.into_scoping(), class_private_mappings }
     }
 
     /// # Panics
@@ -548,6 +556,50 @@ impl<'t> Mangler<'t> {
         let ids = collect_name_symbols(keep_names, scoping, nodes);
         (ids.iter().map(|id| scoping.symbol_name(*id)).collect(), ids)
     }
+
+    /// Collects and generates mangled names for private members using semantic information
+    /// Returns a Vec where each element corresponds to a class in declaration order
+    fn collect_private_members_from_semantic(
+        semantic: &Semantic<'_>,
+    ) -> std::vec::Vec<FxHashMap<String, CompactStr>> {
+        let classes = semantic.classes();
+        let mut result = std::vec::Vec::new();
+
+        // Process each class in declaration order
+        for class_elements in &classes.elements {
+            let mut private_members = FxHashSet::default();
+
+            // Collect private member names for this class
+            for element in class_elements {
+                if element.is_private {
+                    private_members.insert(element.name.as_ref().to_string());
+                }
+            }
+
+            // Generate mapping for this class (reusing names across classes)
+            let mut mapping = FxHashMap::default();
+            let mut count = 0;
+
+            for name in &private_members {
+                let mangled = loop {
+                    let candidate = base54(count);
+                    count += 1;
+
+                    // Ensure the mangled name doesn't conflict with JavaScript keywords
+                    let candidate_str = candidate.as_str();
+                    if !is_keyword(candidate_str) && !is_special_name(candidate_str) {
+                        break CompactStr::new(candidate_str);
+                    }
+                };
+
+                mapping.insert(name.clone(), mangled);
+            }
+
+            result.push(mapping);
+        }
+
+        result
+    }
 }
 
 fn is_special_name(name: &str) -> bool {

crates/oxc_minifier/examples/mangler.rs

@@ -62,6 +62,10 @@ fn main() -> std::io::Result<()> {
 fn mangler(source_text: &str, source_type: SourceType, options: MangleOptions) -> String {
     let allocator = Allocator::default();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
-    let symbol_table = Mangler::new().with_options(options).build(&ret.program);
-    Codegen::new().with_scoping(Some(symbol_table)).build(&ret.program).code
+    let mangler_return = Mangler::new().with_options(options).build(&ret.program);
+    Codegen::new()
+        .with_scoping(Some(mangler_return.scoping))
+        .with_private_member_mappings(Some(mangler_return.class_private_mappings))
+        .build(&ret.program)
+        .code
 }

crates/oxc_minifier/tests/mangler/mod.rs

@@ -11,8 +11,12 @@ fn mangle(source_text: &str, options: MangleOptions) -> String {
     let source_type = SourceType::mjs();
     let ret = Parser::new(&allocator, source_text, source_type).parse();
     let program = ret.program;
-    let symbol_table = Mangler::new().with_options(options).build(&program);
-    Codegen::new().with_scoping(Some(symbol_table)).build(&program).code
+    let mangler_return = Mangler::new().with_options(options).build(&program);
+    Codegen::new()
+        .with_scoping(Some(mangler_return.scoping))
+        .with_private_member_mappings(Some(mangler_return.class_private_mappings))
+        .build(&program)
+        .code
 }
 
 #[test]
@@ -100,3 +104,31 @@ fn mangler() {
         insta::assert_snapshot!("mangler", snapshot);
     });
 }
+
+#[test]
+fn private_member_mangling() {
+    let cases = [
+        "class Foo { #privateField = 1; method() { return this.#privateField; } }",
+        "class Foo { #a = 1; #b = 2; method() { return this.#a + this.#b; } }",
+        "class Foo { #method() { return 1; } publicMethod() { return this.#method(); } }",
+        "class Foo { #field; #method() { return this.#field; } get() { return this.#method(); } }",
+        "class Foo { #x; check() { return #x in this; } }",
+        // Nested classes
+        "class Outer { #outerField = 1; inner() { return class Inner { #innerField = 2; get() { return this.#innerField; } }; } }",
+        // Mixed public and private
+        "class Foo { publicField = 1; #privateField = 2; getSum() { return this.publicField + this.#privateField; } }",
+        // Test same names across different classes should reuse mangled names
+        "class A { #field = 1; #method() { return this.#field; } } class B { #field = 2; #method() { return this.#field; } }",
+    ];
+
+    let mut snapshot = String::new();
+    cases.into_iter().fold(&mut snapshot, |w, case| {
+        let options = MangleOptions::default();
+        write!(w, "{case}\n{}\n", mangle(case, options)).unwrap();
+        w
+    });
+
+    insta::with_settings!({ prepend_module_to_snapshot => false, omit_expression => true }, {
+        insta::assert_snapshot!("private_member_mangling", snapshot);
+    });
+}