feat(minifier): remove unused assignment expression

closes #11469

Author: oxc-bot

crates/oxc_ast/src/ast_impl/js.rs

@@ -974,6 +974,21 @@ impl<'a> AssignmentTargetMaybeDefault<'a> {
             _ => None,
         }
     }
+
+    /// Returns mut identifier bound by this assignment target.
+    pub fn identifier_mut(&mut self) -> Option<&mut IdentifierReference<'a>> {
+        match self {
+            AssignmentTargetMaybeDefault::AssignmentTargetIdentifier(id) => Some(id),
+            Self::AssignmentTargetWithDefault(target) => {
+                if let AssignmentTarget::AssignmentTargetIdentifier(id) = &mut target.binding {
+                    Some(id)
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
 }
 
 impl Statement<'_> {

crates/oxc_ecmascript/src/constant_evaluation/mod.rs

@@ -99,6 +99,20 @@ pub trait ConstantEvaluation<'a>: MayHaveSideEffects<'a> {
     }
 }
 
+impl<'a, T: ConstantEvaluation<'a>> ConstantEvaluation<'a> for Option<T> {
+    fn evaluate_value(&self, ctx: &impl ConstantEvaluationCtx<'a>) -> Option<ConstantValue<'a>> {
+        self.as_ref().and_then(|t| t.evaluate_value(ctx))
+    }
+
+    fn evaluate_value_to(
+        &self,
+        ctx: &impl ConstantEvaluationCtx<'a>,
+        target_ty: Option<ValueType>,
+    ) -> Option<ConstantValue<'a>> {
+        self.as_ref().and_then(|t| t.evaluate_value_to(ctx, target_ty))
+    }
+}
+
 impl<'a> ConstantEvaluation<'a> for IdentifierReference<'a> {
     fn evaluate_value_to(
         &self,

crates/oxc_ecmascript/src/side_effects/may_have_side_effects.rs

@@ -22,6 +22,12 @@ pub trait MayHaveSideEffects<'a> {
     fn may_have_side_effects(&self, ctx: &impl MayHaveSideEffectsContext<'a>) -> bool;
 }
 
+impl<'a, T: MayHaveSideEffects<'a>> MayHaveSideEffects<'a> for Option<T> {
+    fn may_have_side_effects(&self, ctx: &impl MayHaveSideEffectsContext<'a>) -> bool {
+        self.as_ref().is_some_and(|t| t.may_have_side_effects(ctx))
+    }
+}
+
 impl<'a> MayHaveSideEffects<'a> for Expression<'a> {
     fn may_have_side_effects(&self, ctx: &impl MayHaveSideEffectsContext<'a>) -> bool {
         match self {

crates/oxc_minifier/src/ctx.rs

@@ -7,11 +7,11 @@ use oxc_ecmascript::{
     },
     side_effects::{MayHaveSideEffects, PropertyReadSideEffects},
 };
-use oxc_semantic::{IsGlobalReference, Scoping};
+use oxc_semantic::{IsGlobalReference, Scoping, SymbolId};
 use oxc_span::format_atom;
 use oxc_syntax::reference::ReferenceId;
 
-use crate::{options::CompressOptions, state::MinifierState};
+use crate::{options::CompressOptions, state::MinifierState, symbol_value::SymbolValue};
 
 pub type TraverseCtx<'a> = oxc_traverse::TraverseCtx<'a, MinifierState<'a>>;
 
@@ -50,7 +50,7 @@ impl<'a> oxc_ecmascript::is_global_reference::IsGlobalReference<'a> for Ctx<'a,
         self.scoping()
             .get_reference(reference_id)
             .symbol_id()
-            .and_then(|symbol_id| self.state.constant_values.get(&symbol_id))
+            .and_then(|symbol_id| self.state.symbol_values.get_constant_value(symbol_id))
             .cloned()
     }
 }
@@ -164,6 +164,46 @@ impl<'a> Ctx<'a, '_> {
         false
     }
 
+    pub fn init_value(&mut self, symbol_id: SymbolId, constant: Option<ConstantValue<'a>>) {
+        let mut exported = false;
+        if self.scoping.current_scope_id() == self.scoping().root_scope_id() {
+            for ancestor in self.ancestors() {
+                if ancestor.is_export_named_declaration()
+                    || ancestor.is_export_all_declaration()
+                    || ancestor.is_export_default_declaration()
+                {
+                    exported = true;
+                }
+            }
+        }
+
+        let for_statement_init = self.ancestors().nth(1).is_some_and(|ancestor| {
+            ancestor.is_parent_of_for_statement_init() || ancestor.is_parent_of_for_statement_left()
+        });
+
+        let mut read_references_count = 0;
+        let mut write_references_count = 0;
+        for r in self.scoping().get_resolved_references(symbol_id) {
+            if r.is_read() {
+                read_references_count += 1;
+            }
+            if r.is_write() {
+                write_references_count += 1;
+            }
+        }
+
+        let scope_id = self.scoping.current_scope_id();
+        let symbol_value = SymbolValue {
+            constant,
+            exported,
+            for_statement_init,
+            read_references_count,
+            write_references_count,
+            scope_id,
+        };
+        self.state.symbol_values.init_value(symbol_id, symbol_value);
+    }
+
     /// If two expressions are equal.
     /// Special case `undefined` == `void 0`
     pub fn expr_eq(&self, a: &Expression<'a>, b: &Expression<'a>) -> bool {

crates/oxc_minifier/src/lib.rs

@@ -8,6 +8,7 @@ mod keep_var;
 mod options;
 mod peephole;
 mod state;
+mod symbol_value;
 
 #[cfg(test)]
 mod tester;

crates/oxc_minifier/src/peephole/fold_constants.rs

@@ -7,7 +7,6 @@ use oxc_ecmascript::{
 };
 use oxc_span::GetSpan;
 use oxc_syntax::operator::{BinaryOperator, LogicalOperator};
-use oxc_traverse::Ancestor;
 
 use crate::ctx::Ctx;
 
@@ -40,20 +39,6 @@ impl<'a> PeepholeOptimizations {
             *expr = folded_expr;
             ctx.state.changed = true;
         }
-
-        // Save `const value = false` into constant values.
-        if let Ancestor::VariableDeclaratorInit(decl) = ctx.parent() {
-            // TODO: Check for no write references.
-            if decl.kind().is_const() {
-                if let BindingPatternKind::BindingIdentifier(ident) = &decl.id().kind {
-                    // TODO: refactor all the above code to return value instead of expression, to avoid calling `evaluate_value` again.
-                    if let Some(value) = expr.evaluate_value(ctx) {
-                        let symbol_id = ident.symbol_id();
-                        ctx.state.constant_values.insert(symbol_id, value);
-                    }
-                }
-            }
-        }
     }
 
     #[expect(clippy::float_cmp)]

crates/oxc_minifier/src/peephole/inline.rs

@@ -0,0 +1,60 @@
+use oxc_ast::ast::*;
+use oxc_ecmascript::constant_evaluation::{ConstantEvaluation, ConstantValue};
+use oxc_span::GetSpan;
+
+use crate::ctx::Ctx;
+
+use super::PeepholeOptimizations;
+
+impl<'a> PeepholeOptimizations {
+    pub fn init_symbol_value(&self, decl: &VariableDeclarator<'a>, ctx: &mut Ctx<'a, '_>) {
+        let BindingPatternKind::BindingIdentifier(ident) = &decl.id.kind else { return };
+        let Some(symbol_id) = ident.symbol_id.get() else { return };
+        // Skip for `var` declarations, due to TDZ problems.
+        if decl.kind.is_var() {
+            return;
+        }
+        let value =
+            decl.init.as_ref().map_or(Some(ConstantValue::Undefined), |e| e.evaluate_value(ctx));
+        ctx.init_value(symbol_id, value);
+    }
+
+    pub fn inline_identifier_reference(&self, expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
+        let Expression::Identifier(ident) = expr else { return };
+        let Some(reference_id) = ident.reference_id.get() else { return };
+        let Some(symbol_id) = ctx.scoping().get_reference(reference_id).symbol_id() else { return };
+        let Some(symbol_value) = ctx.state.symbol_values.get_symbol_value(symbol_id) else {
+            return;
+        };
+        // Only inline single reference (for now).
+        if symbol_value.read_references_count > 1 {
+            return;
+        }
+        // Skip if there are write references.
+        if symbol_value.write_references_count > 0 {
+            return;
+        }
+        if symbol_value.for_statement_init {
+            return;
+        }
+        let Some(cv) = &symbol_value.constant else { return };
+        *expr = ctx.value_to_expr(expr.span(), cv.clone());
+        ctx.state.changed = true;
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        CompressOptions,
+        tester::{test_options, test_same},
+    };
+
+    #[test]
+    fn r#const() {
+        let options = CompressOptions::smallest();
+        test_options("const foo = 1; log(foo)", "log(1)", &options);
+        test_options("export const foo = 1; log(foo)", "export const foo = 1; log(1)", &options);
+        test_same("const foo = 1; log(foo), log(foo)");
+    }
+}

crates/oxc_minifier/src/peephole/minimize_conditions.rs

@@ -526,8 +526,9 @@ mod test {
         // In the following test case, we can't remove the duplicate "alert(x);" lines since each "x"
         // refers to a different variable.
         // We only try removing duplicate statements if the AST is normalized and names are unique.
-        test_same(
+        test(
             "if (Math.random() < 0.5) { let x = 3; alert(x); } else { let x = 5; alert(x); }",
+            "if (Math.random() < 0.5) { let x = 3; alert(3); } else { let x = 5; alert(5); }",
         );
     }
 

crates/oxc_minifier/src/peephole/mod.rs

@@ -2,6 +2,7 @@
 
 mod convert_to_dotted_properties;
 mod fold_constants;
+mod inline;
 mod minimize_conditional_expression;
 mod minimize_conditions;
 mod minimize_expression_in_boolean_context;
@@ -102,10 +103,12 @@ impl<'a> PeepholeOptimizations {
 
 impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
     fn enter_program(&mut self, _program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        ctx.state.symbol_values.clear();
         ctx.state.changed = false;
     }
 
     fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        // Remove unused references by visiting the AST again and diff the collected references.
         let refs_before =
             ctx.scoping().resolved_references().flatten().copied().collect::<FxHashSet<_>>();
         let mut counter = ReferencesCounter::default();
@@ -155,18 +158,26 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         ctx: &mut TraverseCtx<'a>,
     ) {
         let mut ctx = Ctx::new(ctx);
-
         self.substitute_variable_declaration(decl, &mut ctx);
     }
 
-    fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
+    fn exit_variable_declarator(
+        &mut self,
+        decl: &mut VariableDeclarator<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
         let mut ctx = Ctx::new(ctx);
+        self.init_symbol_value(decl, &mut ctx);
+    }
 
+    fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
+        let mut ctx = Ctx::new(ctx);
         self.fold_constants_exit_expression(expr, &mut ctx);
         self.minimize_conditions_exit_expression(expr, &mut ctx);
         self.remove_dead_code_exit_expression(expr, &mut ctx);
         self.replace_known_methods_exit_expression(expr, &mut ctx);
         self.substitute_exit_expression(expr, &mut ctx);
+        self.inline_identifier_reference(expr, &mut ctx);
     }
 
     fn exit_unary_expression(&mut self, expr: &mut UnaryExpression<'a>, ctx: &mut TraverseCtx<'a>) {

crates/oxc_minifier/src/peephole/normalize.rs

@@ -454,7 +454,8 @@ mod test {
     #[test]
     fn fold_number_nan() {
         test("foo(Number.NaN)", "foo(NaN)");
-        test_same("let Number; foo(Number.NaN)");
+        test_same("var Number; foo(Number.NaN)");
+        test_same("let Number; foo((void 0).NaN)");
     }
 
     #[test]