refactor(minifier): clean up has_no_side_effect_for_evaluation_same_target

Author: Boshen

crates/oxc_minifier/src/peephole/minimize_conditions.rs

@@ -1075,24 +1075,20 @@ impl<'a> PeepholeOptimizations {
         if self.target < ESTarget::ES2020 {
             return None;
         }
-
         let Expression::AssignmentExpression(assignment_expr) = &mut expr.right else {
             return None;
         };
         if assignment_expr.operator != AssignmentOperator::Assign {
             return None;
         }
-
         let new_op = expr.operator.to_assignment_operator();
-
         if !Self::has_no_side_effect_for_evaluation_same_target(
             &assignment_expr.left,
             &expr.left,
             ctx,
         ) {
             return None;
         }
-
         assignment_expr.span = expr.span;
         assignment_expr.operator = new_op;
         Some(ctx.ast.move_expression(&mut expr.right))
@@ -1129,37 +1125,31 @@ impl<'a> PeepholeOptimizations {
     ///
     /// - `a`, `a`
     /// - `a.b`, `a.b`
-    /// - `a.#b`, `a.#b`
+    /// - `a["b"]`, `a["b"]`
     fn has_no_side_effect_for_evaluation_same_target(
         assignment_target: &AssignmentTarget,
         expr: &Expression,
         ctx: &mut TraverseCtx<'a>,
     ) -> bool {
-        match (&assignment_target, &expr) {
-            (
-                AssignmentTarget::AssignmentTargetIdentifier(write_id_ref),
-                Expression::Identifier(read_id_ref),
-            ) => write_id_ref.name == read_id_ref.name,
-            (
-                AssignmentTarget::StaticMemberExpression(_),
-                Expression::StaticMemberExpression(_),
-            )
-            | (
-                AssignmentTarget::PrivateFieldExpression(_),
-                Expression::PrivateFieldExpression(_),
-            ) => {
-                let write_expr = assignment_target.to_member_expression();
-                let read_expr = expr.to_member_expression();
-                let Expression::Identifier(write_expr_object_id) = &write_expr.object() else {
-                    return false;
-                };
+        if let (
+            AssignmentTarget::AssignmentTargetIdentifier(write_id_ref),
+            Expression::Identifier(read_id_ref),
+        ) = (assignment_target, expr)
+        {
+            return write_id_ref.name == read_id_ref.name;
+        }
+        if let Some(write_expr) = assignment_target.as_member_expression() {
+            let Expression::Identifier(write_expr_object_id) = &write_expr.object() else {
+                return false;
+            };
+            if let Some(read_expr) = expr.as_member_expression() {
                 // It should also return false when the reference might refer to a reference value created by a with statement
                 // when the minifier supports with statements
-                !Ctx(ctx).is_global_reference(write_expr_object_id)
-                    && write_expr.content_eq(read_expr)
+                return !Ctx(ctx).is_global_reference(write_expr_object_id)
+                    && write_expr.content_eq(read_expr);
             }
-            _ => false,
         }
+        false
     }
 
     /// Compress `a = a + b` to `a += b`