fix: object rest transformation

crates/tree_shaker/src/entity/object/delete.rs

@@ -3,7 +3,7 @@ use crate::{
   analyzer::Analyzer,
   consumable::Consumable,
   entity::{consumed_object, Entity, EntityTrait, LiteralEntity},
-  mangling::MangleConstraint,
+  mangling::{MangleConstraint, ManglingDep},
 };
 
 impl<'a> ObjectEntity<'a> {
@@ -54,12 +54,12 @@ impl<'a> ObjectEntity<'a> {
                   let prev_atom = property.mangling.unwrap();
                   analyzer.consumable((
                     dep,
-                    // This is a hack
-                    analyzer.factory.mangable(
-                      analyzer.factory.immutable_unknown,
-                      (prev_key, key),
-                      analyzer.factory.alloc(MangleConstraint::Eq(prev_atom, key_atom.unwrap())),
-                    ) as Entity<'a>,
+                    ManglingDep {
+                      deps: (prev_key, key),
+                      constraint: analyzer
+                        .factory
+                        .alloc(MangleConstraint::Eq(prev_atom, key_atom.unwrap())),
+                    },
                   ))
                 } else {
                   dep

crates/tree_shaker/src/mangling/mangler.rs

@@ -62,7 +62,7 @@ impl<'a> Mangler<'a> {
           self.resolve_identity_group(*identity_group)
         } else if uniqueness_groups.is_empty() {
           // This is quite weird, isn't it?
-          "a"
+          "_"
         } else {
           let mut n =
             uniqueness_groups.iter().map(|&index| self.uniqueness_groups[index].1).max().unwrap();

crates/tree_shaker/src/nodes/misc/assignment_target_pattern.rs

@@ -114,9 +114,7 @@ impl<'a> Transformer<'a> {
 
         let mut transformed_properties = self.ast_builder.vec();
         for property in properties {
-          if let Some(property) =
-            self.transform_assignment_target_property(property, rest.is_some())
-          {
+          if let Some(property) = self.transform_assignment_target_property(property) {
             transformed_properties.push(property);
           }
         }

crates/tree_shaker/src/nodes/misc/assignment_target_property.rs

@@ -1,6 +1,4 @@
-use crate::{
-  analyzer::Analyzer, ast::AstKind2, dep::DepId, entity::Entity, transformer::Transformer,
-};
+use crate::{analyzer::Analyzer, ast::AstKind2, entity::Entity, transformer::Transformer};
 use oxc::{
   ast::ast::{
     AssignmentTargetProperty, AssignmentTargetPropertyIdentifier, AssignmentTargetPropertyProperty,
@@ -20,7 +18,7 @@ impl<'a> Analyzer<'a> {
     node: &'a AssignmentTargetProperty<'a>,
     value: Entity<'a>,
   ) -> Entity<'a> {
-    let dep = self.consumable(DepId::from(AstKind2::AssignmentTargetProperty(node)));
+    let dep = self.consumable(AstKind2::AssignmentTargetProperty(node));
     match node {
       AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(node) => {
         let key = self.factory.string(node.binding.name.as_str());
@@ -58,9 +56,8 @@ impl<'a> Transformer<'a> {
   pub fn transform_assignment_target_property(
     &self,
     node: &'a AssignmentTargetProperty<'a>,
-    has_rest: bool,
   ) -> Option<AssignmentTargetProperty<'a>> {
-    let need_binding = has_rest || self.is_referred(AstKind2::AssignmentTargetProperty(node));
+    let need_binding = self.is_referred(AstKind2::AssignmentTargetProperty(node));
     match node {
       AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(node) => {
         let data =

crates/tree_shaker/src/nodes/misc/binding_pattern.rs

@@ -178,7 +178,7 @@ impl<'a> Transformer<'a> {
         let mut transformed_properties = self.ast_builder.vec();
         for property in properties {
           let dep = AstKind2::BindingProperty(property);
-          let need_property = rest.is_some() || self.is_referred(dep);
+          let need_property = self.is_referred(dep);
 
           let BindingProperty { span, key, value, shorthand, computed } = property;
 

crates/tree_shaker/src/nodes/misc/rest.rs

@@ -13,7 +13,6 @@ impl<'a> Analyzer<'a> {
     for key in enumerated {
       rest.delete_property(self, self.factory.empty_consumable, key);
     }
-
     rest
   }
 }