fix: object mangling group, super class, object has_own, function.prototype

Author: kermanx

crates/jsshaker/src/builtins/globals/object_constructor.rs

@@ -261,7 +261,7 @@ impl<'a> Builtins<'a> {
         let deps = analyzer.dep((proto, dep));
         (deps, ObjectPrototype::Unknown(deps))
       };
-      let mangling = analyzer.new_object_mangling_group();
+      let mangling = analyzer.mangler.new_object_group();
       let object = analyzer.new_empty_object(prototype, Some(mangling));
       object.add_extra_dep(deps);
       object.into()

crates/jsshaker/src/builtins/prototypes/function.rs

@@ -33,12 +33,11 @@ pub fn create_function_prototype<'a>(factory: &'a Factory<'a>) -> BuiltinPrototy
         bound_this,
         bound_args,
       });
-      analyzer.factory.computed(analyzer.new_function(CalleeNode::BoundFunction(bound_fn)).into(), (dep, args.get_last_shallow_dep(analyzer)))
+      analyzer.factory.computed(analyzer.new_function(CalleeNode::BoundFunction(bound_fn), false).0.into(), (dep, args.get_last_shallow_dep(analyzer)))
     }),
     "length" => factory.unknown_number,
     "arguments" => factory.unknown,
     "caller" => factory.unknown,
     "name" => factory.unknown_string,
-    "prototype" => factory.unknown,
   })
 }

crates/jsshaker/src/builtins/prototypes/mod.rs

@@ -101,6 +101,10 @@ impl<'a> BuiltinPrototype<'a> {
       analyzer.factory.computed_unknown(dep)
     }
   }
+
+  pub fn test_has_own(&self, key: PropertyKeyValue<'a>) -> Option<bool> {
+    if self.get(&key).is_some() { Some(true) } else { None }
+  }
 }
 
 pub struct BuiltinPrototypes<'a> {

crates/jsshaker/src/mangling/constraint.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use rustc_hash::FxHashSet;
+use oxc::allocator::{self, TakeIn};
 
 use super::{AtomState, MangleAtom};
 use super::{Mangler, UniquenessGroupId};
@@ -116,7 +116,11 @@ impl<'a> Mangler<'a> {
             }
           }
         } else {
-          let group = uniqueness_groups.push((vec![a, b], 0, FxHashSet::default()));
+          let group = uniqueness_groups.alloc((
+            allocator::Vec::from_array_in([a, b], self.allocator),
+            0,
+            allocator::HashSet::new_in(self.allocator),
+          ));
           ua.insert(UniquenessConstraint::Group(group));
           ub.insert(UniquenessConstraint::Group(group));
         }
@@ -143,7 +147,7 @@ impl<'a> Mangler<'a> {
   }
 
   pub fn mark_uniqueness_group_non_mangable(&mut self, group: UniquenessGroupId) {
-    for atom in mem::take(&mut self.uniqueness_groups[group].0) {
+    for atom in self.uniqueness_groups[group].0.take_in(self.allocator) {
       self.mark_atom_non_mangable(atom);
     }
   }

crates/jsshaker/src/mangling/mangler.rs

@@ -7,6 +7,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
   analyzer::Factory,
+  define_box_bump_idx,
   dep::DepAtom,
   utils::box_bump::BoxBump,
   value::{LiteralValue, Value},
@@ -19,9 +20,10 @@ oxc_index::define_index_type! {
   DISABLE_MAX_INDEX_CHECK = cfg!(not(debug_assertions));
 }
 
-oxc_index::define_index_type! {
-  pub struct UniquenessGroupId = u32;
-  DISABLE_MAX_INDEX_CHECK = cfg!(not(debug_assertions));
+type UniquenessGroup<'a> = (Vec<MangleAtom>, usize, FxHashSet<&'a str>);
+
+define_box_bump_idx! {
+  pub struct UniquenessGroupId for UniquenessGroup<'static>;
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -37,8 +39,11 @@ pub enum AtomState<'a> {
   Builtin,
 }
 
-type UniquenessGroups<'a> =
-  IndexVec<UniquenessGroupId, (Vec<MangleAtom>, usize, FxHashSet<&'a str>)>;
+type UniquenessGroups<'a> = BoxBump<
+  'a,
+  UniquenessGroupId,
+  (allocator::Vec<'a, MangleAtom>, usize, allocator::HashSet<'a, &'a str>),
+>;
 
 pub struct Mangler<'a> {
   pub enabled: bool,
@@ -47,6 +52,8 @@ pub struct Mangler<'a> {
 
   pub states: BoxBump<'a, MangleAtom, AtomState<'a>>,
   pub constant_nodes: FxHashMap<DepAtom, (Option<MangleAtom>, Value<'a>)>,
+  pub object_groups: FxHashMap<DepAtom, UniquenessGroupId>,
+  pub prototype_groups: FxHashMap<DepAtom, UniquenessGroupId>,
 
   /// (atoms, resolved_name)[]
   pub identity_groups: IndexVec<IdentityGroupId, (Vec<MangleAtom>, Option<&'a str>)>,
@@ -63,8 +70,10 @@ impl<'a> Mangler<'a> {
       allocator,
       states,
       constant_nodes: FxHashMap::default(),
+      object_groups: FxHashMap::default(),
+      prototype_groups: FxHashMap::default(),
       identity_groups: IndexVec::new(),
-      uniqueness_groups: IndexVec::new(),
+      uniqueness_groups: BoxBump::new(allocator),
     }
   }
 
@@ -83,6 +92,34 @@ impl<'a> Mangler<'a> {
       .1
   }
 
+  pub fn new_object_group(&mut self) -> UniquenessGroupId {
+    self.uniqueness_groups.alloc((
+      allocator::Vec::new_in(self.allocator),
+      0,
+      allocator::HashSet::new_in(self.allocator),
+    ))
+  }
+
+  pub fn use_object_group(&mut self, node: impl Into<DepAtom>) -> UniquenessGroupId {
+    *self.object_groups.entry(node.into()).or_insert_with(|| {
+      self.uniqueness_groups.alloc((
+        allocator::Vec::new_in(self.allocator),
+        0,
+        allocator::HashSet::new_in(self.allocator),
+      ))
+    })
+  }
+
+  pub fn use_prototype_group(&mut self, node: impl Into<DepAtom>) -> UniquenessGroupId {
+    *self.prototype_groups.entry(node.into()).or_insert_with(|| {
+      self.uniqueness_groups.alloc((
+        allocator::Vec::new_in(self.allocator),
+        0,
+        allocator::HashSet::new_in(self.allocator),
+      ))
+    })
+  }
+
   pub fn new_atom(&self, str: &'a str) -> MangleAtom {
     self.states.alloc(AtomState::Constrained(str, None, allocator::HashSet::new_in(self.allocator)))
   }

crates/jsshaker/src/nodes/expr/arrow_function_expression.rs

@@ -17,7 +17,7 @@ impl<'a> Analyzer<'a> {
     &mut self,
     node: &'a ArrowFunctionExpression<'a>,
   ) -> Entity<'a> {
-    self.new_function(CalleeNode::ArrowFunctionExpression(node)).into()
+    self.new_function(CalleeNode::ArrowFunctionExpression(node), false).0.into()
   }
 
   pub fn call_arrow_function_expression(

crates/jsshaker/src/nodes/expr/call_expression.rs

@@ -94,7 +94,9 @@ impl<'a> Transformer<'a> {
       return Err(callee);
     }
 
-    let need_call = need_val || self.is_included(dep_id) || callee.is_super();
+    let need_call = need_val
+      || self.is_included(dep_id)
+      || (callee.is_super() && self.has_super_class.borrow().last().copied().unwrap_or(false));
 
     if !need_call {
       let callee = self.transform_expression_in_chain(callee, need_optional)?;

crates/jsshaker/src/nodes/misc/class.rs

@@ -1,10 +1,12 @@
+use std::cell::RefCell;
+
 use oxc::{
-  allocator::{self, Allocator},
+  allocator,
   ast::{
     NONE,
     ast::{
-      Class, ClassBody, ClassElement, ClassType, MethodDefinition, MethodDefinitionKind,
-      PropertyDefinitionType, PropertyKind, StaticBlock,
+      Class, ClassBody, ClassElement, ClassType, MethodDefinitionKind, PropertyDefinitionType,
+      PropertyKind, StaticBlock,
     },
   },
   span::GetSpan,
@@ -16,35 +18,30 @@ use crate::{
   dep::DepAtom,
   entity::Entity,
   transformer::Transformer,
-  utils::{CalleeNode, DefaultIn},
+  utils::{CalleeNode, ClassData},
   value::{ObjectPrototype, cache::FnCacheTrackingData, call::FnCallInfo},
 };
 
-struct Data<'a> {
-  pub value: Option<Entity<'a>>,
-  pub constructor: Option<&'a MethodDefinition<'a>>,
-  pub keys: allocator::Vec<'a, Option<Entity<'a>>>,
-  pub super_class: Option<Entity<'a>>,
-}
-
-impl<'a> DefaultIn<'a> for Data<'a> {
-  fn default_in(allocator: &'a Allocator) -> Self {
-    Data {
-      value: None,
+impl<'a> Analyzer<'a> {
+  pub fn exec_class(&mut self, node: &'a Class<'a>) -> Entity<'a> {
+    let data_cell = self.allocator.alloc(RefCell::new(ClassData {
+      initializing: true,
+      included: false,
       constructor: None,
-      keys: allocator::Vec::new_in(allocator),
+      keys: self.factory.vec(),
       super_class: None,
-    }
-  }
-}
+    }));
 
-impl<'a> Analyzer<'a> {
-  pub fn exec_class(&mut self, node: &'a Class<'a>) -> Entity<'a> {
-    let data = self.load_data::<Data>(AstKind2::Class(node));
-    let (class, prototype) = self.new_function_with_prototype(CalleeNode::ClassConstructor(node));
+    let (class, prototype) = self.new_function(CalleeNode::ClassConstructor(node, data_cell), true);
+    let prototype = prototype.unwrap();
+    let mut data = data_cell.borrow_mut();
+    data.initializing = false;
 
     // 1. Execute super class
-    data.super_class = node.super_class.as_ref().map(|node| self.exec_expression(node));
+    data.super_class = node
+      .super_class
+      .as_ref()
+      .map(|node| self.factory.computed(self.exec_expression(node), AstKind2::SuperExpr(node)));
     if let Some(super_class) = &data.super_class {
       // Because we can't re-define the "prototype" property, this should be side-effect free
       if let Some((prototype_dep, super_statics, super_prototype)) =
@@ -80,6 +77,8 @@ impl<'a> Analyzer<'a> {
         data.constructor = Some(method);
       }
     }
+    drop(data);
+    let data = data_cell.borrow();
 
     // 3. Register methods
     for (key, element) in data.keys.iter().zip(node.body.body.iter()) {
@@ -155,14 +154,17 @@ impl<'a> Analyzer<'a> {
 
     // 5. Execute class decorators (ES2025 Stage 3)
     let class = class.into();
-    let final_class = if !node.decorators.is_empty() {
+    let class = if !node.decorators.is_empty() {
       self.exec_decorators(&node.decorators, class)
     } else {
       class
     };
 
-    data.value = Some(final_class);
-    final_class
+    if data.included {
+      self.include(class);
+    }
+
+    class
   }
 
   pub fn declare_class(&mut self, node: &'a Class<'a>, exporting: Option<DepAtom>) {
@@ -180,10 +182,18 @@ impl<'a> Analyzer<'a> {
   pub fn call_class_constructor(
     &mut self,
     node: &'a Class<'a>,
+    data_cell: &RefCell<ClassData<'a>>,
     info: FnCallInfo<'a>,
   ) -> (Entity<'a>, FnCacheTrackingData<'a>) {
+    let data = data_cell.borrow();
+    if info.include && data.initializing {
+      drop(data);
+      let mut data = data_cell.borrow_mut();
+      data.included = true;
+      return (self.factory.undefined, FnCacheTrackingData::worst_case());
+    }
+
     let factory = self.factory;
-    let data = self.load_data::<Data>(AstKind2::Class(node));
 
     self.push_call_scope(info, false, false);
     let super_class = data.super_class.unwrap_or(self.factory.undefined);
@@ -195,7 +205,11 @@ impl<'a> Analyzer<'a> {
 
     if let Some(id) = &node.id {
       self.declare_binding_identifier(id, None, DeclarationKind::NamedFunctionInBody);
-      self.init_binding_identifier(id, DeclarationKind::NamedFunctionInBody, data.value);
+      self.init_binding_identifier(
+        id,
+        DeclarationKind::NamedFunctionInBody,
+        Some(info.func.into()),
+      );
     }
 
     // 1. Init properties
@@ -256,8 +270,11 @@ impl<'a> Transformer<'a> {
         transformed_id
       };
 
-      let super_class = super_class.as_ref().and_then(|node| self.transform_expression(node, true));
+      let super_class = super_class.as_ref().and_then(|node| {
+        self.transform_expression(node, self.is_included(AstKind2::SuperExpr(node)))
+      });
 
+      self.has_super_class.borrow_mut().push(super_class.is_some());
       let body = {
         let ClassBody { span, body } = body.as_ref();
 
@@ -298,6 +315,7 @@ impl<'a> Transformer<'a> {
 
         self.ast.class_body(*span, transformed_body)
       };
+      self.has_super_class.borrow_mut().pop();
 
       let decorators = self.transform_decorators(&node.decorators);
 
@@ -335,6 +353,7 @@ impl<'a> Transformer<'a> {
         }
       }
 
+      self.has_super_class.borrow_mut().push(false);
       for element in &body.body {
         match element {
           ClassElement::StaticBlock(node) => {
@@ -354,6 +373,7 @@ impl<'a> Transformer<'a> {
           _ => {}
         }
       }
+      self.has_super_class.borrow_mut().pop();
 
       if statements.is_empty() {
         None

crates/jsshaker/src/nodes/misc/function.rs

@@ -21,7 +21,7 @@ impl<'a> Analyzer<'a> {
     if self.has_no_shake_notation(node.span) {
       return self.factory.computed_unknown(AstKind2::FunctionNoShake(node));
     }
-    self.new_function(CalleeNode::Function(node)).into()
+    self.new_function(CalleeNode::Function(node), true).0.into()
   }
 
   pub fn declare_function(

crates/jsshaker/src/transformer.rs

@@ -43,6 +43,7 @@ pub struct Transformer<'a> {
   pub need_unused_assignment_target: Cell<bool>,
   pub need_non_nullish_helper: Cell<bool>,
   pub unused_identifier_names: RefCell<FxHashMap<u64, usize>>,
+  pub has_super_class: RefCell<Vec<bool>>,
 }
 
 impl<'a> Transformer<'a> {
@@ -75,6 +76,7 @@ impl<'a> Transformer<'a> {
       need_unused_assignment_target: Cell::new(false),
       need_non_nullish_helper: Cell::new(false),
       unused_identifier_names: Default::default(),
+      has_super_class: Default::default(),
     }
   }