refactor(es/minifier): Remove mutated and mutation_by_call_count (#…

…7890)

**Description:**

`mutated` can be seen as a combination of `reassigned` and `has_property_mutation`, and `mutation_by_call_count` is simply useless.

crates/swc_ecma_minifier/src/compress/optimize/inline.rs

@@ -98,9 +98,7 @@ impl Optimizer<'_> {
             //
             // TODO: Allow `length` in usage.accessed_props
             if usage.declared
-                && !usage.reassigned
-                && !usage.mutated
-                && !usage.has_property_mutation
+                && !usage.mutated()
                 && usage.accessed_props.is_empty()
                 && !usage.is_infected()
                 && is_inline_enabled
@@ -165,7 +163,7 @@ impl Optimizer<'_> {
                 }
             }
 
-            if !usage.mutated {
+            if !usage.mutated() {
                 self.mode.store(ident.to_id(), &*init);
             }
 
@@ -177,7 +175,8 @@ impl Optimizer<'_> {
             // new variant is added for multi inline, think carefully
             if is_inline_enabled
                 && usage.declared_count == 1
-                && usage.can_inline_var()
+                && usage.assign_count == 0
+                && (!usage.has_property_mutation || !usage.reassigned)
                 && match init {
                     Expr::Ident(Ident {
                         sym: js_word!("eval"),
@@ -323,7 +322,7 @@ impl Optimizer<'_> {
                 && usage.declared
                 && may_remove
                 && !usage.reassigned
-                && (usage.can_inline_var() || usage.is_mutated_only_by_one_call())
+                && usage.assign_count == 0
                 && ref_count == 1
             {
                 match init {

crates/swc_ecma_minifier/src/compress/optimize/props.rs

@@ -29,13 +29,11 @@ impl Optimizer<'_> {
                 .vars
                 .get(&name.to_id())
                 .map(|v| {
-                    !v.mutated
-                        && v.mutation_by_call_count == 0
+                    !v.mutated()
                         && !v.used_as_ref
                         && !v.used_as_arg
                         && !v.used_in_cond
                         && (!v.is_fn_local || !self.mode.should_be_very_correct())
-                        && !v.reassigned
                         && !v.is_infected()
                 })
                 .unwrap_or(false)
@@ -153,8 +151,7 @@ impl Optimizer<'_> {
                 .map(|v| {
                     v.ref_count == 1
                         && v.has_property_access
-                        && !v.mutated
-                        && v.mutation_by_call_count == 0
+                        && !v.mutated()
                         && v.is_fn_local
                         && !v.executed_multiple_time
                         && !v.used_as_arg

crates/swc_ecma_minifier/src/compress/optimize/unused.rs

@@ -215,8 +215,7 @@ impl Optimizer<'_> {
                         return true;
                     }
 
-                    if !usage.mutated && !usage.reassigned && usage.no_side_effect_for_member_access
-                    {
+                    if !usage.mutated() && usage.no_side_effect_for_member_access {
                         return false;
                     }
                 }

crates/swc_ecma_minifier/src/program_data.rs

@@ -65,7 +65,6 @@ pub(crate) struct VarUsageInfo {
     pub(crate) declared_as_for_init: bool,
 
     pub(crate) assign_count: u32,
-    pub(crate) mutation_by_call_count: u32,
 
     /// The number of direct and indirect reference to this identifier.
     /// ## Things to note
@@ -75,8 +74,6 @@ pub(crate) struct VarUsageInfo {
 
     /// The variable itself is assigned after reference.
     pub(crate) reassigned: bool,
-    /// The variable itself or a property of it is modified.
-    pub(crate) mutated: bool,
 
     pub(crate) has_property_access: bool,
     pub(crate) has_property_mutation: bool,
@@ -139,10 +136,8 @@ impl Default for VarUsageInfo {
             declared_as_fn_expr: Default::default(),
             declared_as_for_init: Default::default(),
             assign_count: Default::default(),
-            mutation_by_call_count: Default::default(),
             usage_count: Default::default(),
             reassigned: Default::default(),
-            mutated: Default::default(),
             has_property_access: Default::default(),
             has_property_mutation: Default::default(),
             exported: Default::default(),
@@ -170,16 +165,13 @@ impl Default for VarUsageInfo {
 }
 
 impl VarUsageInfo {
-    pub(crate) fn is_mutated_only_by_one_call(&self) -> bool {
-        self.assign_count == 0 && self.mutation_by_call_count == 1
-    }
-
     pub(crate) fn is_infected(&self) -> bool {
         !self.infects_to.is_empty()
     }
 
-    pub(crate) fn can_inline_var(&self) -> bool {
-        !self.mutated || (self.assign_count == 0 && !self.reassigned)
+    /// The variable itself or a property of it is modified.
+    pub(crate) fn mutated(&self) -> bool {
+        self.assign_count > 0 || self.has_property_mutation
     }
 
     pub(crate) fn can_inline_fn_once(&self) -> bool {
@@ -230,6 +222,8 @@ impl Storage for ProgramData {
                         || (var_info.var_initialized && !e.get().var_initialized);
 
                     if var_info.var_initialized {
+                        // If it is inited in some other child scope and also inited in current
+                        // scope
                         if e.get().var_initialized || e.get().ref_count > 0 {
                             e.get_mut().assign_count += 1;
                             e.get_mut().reassigned = true;
@@ -242,6 +236,8 @@ impl Storage for ProgramData {
                         // If it is inited in some other child scope, but referenced in
                         // current child scope
                         if !inited && e.get().var_initialized && var_info.ref_count > 0 {
+                            e.get_mut().var_initialized = false;
+                            e.get_mut().assign_count += 1;
                             e.get_mut().reassigned = true
                         }
                     }
@@ -256,8 +252,6 @@ impl Storage for ProgramData {
                         }
                     }
 
-                    e.get_mut().mutated |= var_info.mutated;
-
                     e.get_mut().has_property_access |= var_info.has_property_access;
                     e.get_mut().has_property_mutation |= var_info.has_property_mutation;
                     e.get_mut().exported |= var_info.exported;
@@ -276,7 +270,6 @@ impl Storage for ProgramData {
                     e.get_mut().executed_multiple_time |= var_info.executed_multiple_time;
                     e.get_mut().used_in_cond |= var_info.used_in_cond;
                     e.get_mut().assign_count += var_info.assign_count;
-                    e.get_mut().mutation_by_call_count += var_info.mutation_by_call_count;
                     e.get_mut().usage_count += var_info.usage_count;
 
                     e.get_mut().infects_to.extend(var_info.infects_to);
@@ -362,7 +355,6 @@ impl Storage for ProgramData {
                 tracing::trace!("declare_decl(`{}`): Already declared", i);
             }
 
-            v.mutated = true;
             v.reassigned = true;
             v.assign_count += 1;
         }
@@ -398,7 +390,7 @@ impl Storage for ProgramData {
         self.initialized_vars.truncate(len)
     }
 
-    fn mark_property_mutattion(&mut self, id: Id, ctx: Ctx) {
+    fn mark_property_mutation(&mut self, id: Id, ctx: Ctx) {
         let e = self.vars.entry(id).or_default();
         e.has_property_mutation = true;
 
@@ -484,10 +476,6 @@ impl VarDataLike for VarUsageInfo {
         *self.accessed_props.entry(name).or_default() += 1;
     }
 
-    fn mark_mutated(&mut self) {
-        self.mutated = true;
-    }
-
     fn mark_used_as_ref(&mut self) {
         self.used_as_ref = true;
     }
@@ -610,9 +598,6 @@ impl ProgramData {
 
         let call_may_mutate = ctx.in_call_arg_of == Some(CalleeKind::Unknown);
 
-        // Passing object as a argument is possibly modification.
-        e.mutated |= is_modify || (call_may_mutate && ctx.is_exact_arg);
-
         e.executed_multiple_time |= ctx.executed_multiple_time;
         e.used_in_cond |= ctx.in_cond;
 
@@ -647,15 +632,11 @@ impl ProgramData {
                 self.report(other.0, ctx, true, dejavu)
             }
         } else {
-            if call_may_mutate && ctx.is_exact_arg {
-                e.mutation_by_call_count += 1;
-            }
-
             e.usage_count += 1;
         }
 
         if call_may_mutate && ctx.is_exact_arg {
-            self.mark_property_mutattion(i, ctx)
+            self.mark_property_mutation(i, ctx)
         }
     }
 }

crates/swc_ecma_usage_analyzer/src/analyzer/mod.rs

@@ -919,8 +919,8 @@ where
                 v.add_accessed_property(prop.sym.clone());
             }
 
-            if self.ctx.in_assign_lhs || self.ctx.is_delete_arg {
-                self.data.mark_property_mutattion(obj.to_id(), self.ctx)
+            if self.ctx.in_assign_lhs || self.ctx.in_update_arg || self.ctx.is_delete_arg {
+                self.data.mark_property_mutation(obj.to_id(), self.ctx)
             }
         })
     }

crates/swc_ecma_usage_analyzer/src/analyzer/storage.rs

@@ -30,7 +30,7 @@ pub trait Storage: Sized + Default {
     fn get_initialized_cnt(&self) -> usize;
     fn truncate_initialized_cnt(&mut self, len: usize);
 
-    fn mark_property_mutattion(&mut self, id: Id, ctx: Ctx);
+    fn mark_property_mutation(&mut self, id: Id, ctx: Ctx);
 }
 
 pub trait ScopeDataLike: Sized + Default + Clone {
@@ -65,8 +65,6 @@ pub trait VarDataLike: Sized {
 
     fn add_accessed_property(&mut self, name: JsWord);
 
-    fn mark_mutated(&mut self);
-
     fn mark_used_as_ref(&mut self);
 
     fn add_infects_to(&mut self, other: Access);