feat(minifier): remove unused variable declaration

part of #10033

Author: Boshen

crates/oxc_minifier/examples/minifier.rs

@@ -50,7 +50,7 @@ fn minify(
     let mut program = ret.program;
     let options = MinifierOptions {
         mangle: mangle.then(MangleOptions::default),
-        compress: Some(CompressOptions::default()),
+        compress: Some(CompressOptions::smallest()),
     };
     let ret = Minifier::new(options).build(allocator, &mut program);
     Codegen::new()

crates/oxc_minifier/src/options.rs

@@ -24,6 +24,9 @@ pub struct CompressOptions {
     /// Default `false`
     pub drop_console: bool,
 
+    /// Drop unreferenced functions and variables.
+    pub unused: CompressOptionsUnused,
+
     /// Keep function / class names.
     pub keep_names: CompressOptionsKeepNames,
 
@@ -46,6 +49,7 @@ impl CompressOptions {
             keep_names: CompressOptionsKeepNames::all_false(),
             drop_debugger: true,
             drop_console: true,
+            unused: CompressOptionsUnused::Remove,
             treeshake: TreeShakeOptions::default(),
         }
     }
@@ -56,11 +60,20 @@ impl CompressOptions {
             keep_names: CompressOptionsKeepNames::all_true(),
             drop_debugger: false,
             drop_console: false,
+            unused: CompressOptionsUnused::Keep,
             treeshake: TreeShakeOptions::default(),
         }
     }
 }
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+pub enum CompressOptionsUnused {
+    #[default]
+    Remove,
+    KeepAssign,
+    Keep,
+}
+
 #[derive(Debug, Clone, Copy, Default)]
 pub struct CompressOptionsKeepNames {
     /// Keep function names so that `Function.prototype.name` is preserved.

crates/oxc_minifier/src/peephole/minimize_statements.rs

@@ -8,7 +8,7 @@ use oxc_semantic::ScopeId;
 use oxc_span::{ContentEq, GetSpan};
 use oxc_traverse::Ancestor;
 
-use crate::{ctx::Ctx, keep_var::KeepVar};
+use crate::{CompressOptionsUnused, ctx::Ctx, keep_var::KeepVar};
 
 use super::{PeepholeOptimizations, State};
 
@@ -303,7 +303,7 @@ impl<'a> PeepholeOptimizations {
                 result.push(Statement::ContinueStatement(s));
             }
             Statement::VariableDeclaration(var_decl) => {
-                self.handle_variable_declaration(var_decl, result, state);
+                self.handle_variable_declaration(var_decl, result, state, ctx);
             }
             Statement::ExpressionStatement(expr_stmt) => {
                 self.handle_expression_statement(expr_stmt, result, state, ctx);
@@ -367,20 +367,59 @@ impl<'a> PeepholeOptimizations {
         false
     }
 
+    /// For variable declarations:
+    /// * merge with the previous variable declarator if their kinds are the same
+    /// * remove the variable declarator if it is unused
+    /// * keep the initializer if it has side effects
     fn handle_variable_declaration(
         &self,
-        mut var_decl: Box<'a, VariableDeclaration<'a>>,
+        var_decl: Box<'a, VariableDeclaration<'a>>,
         result: &mut Vec<'a, Statement<'a>>,
         state: &mut State,
+        ctx: &mut Ctx<'a, '_>,
     ) {
-        if let Some(Statement::VariableDeclaration(prev_var_decl)) = result.last_mut() {
+        if let Some(Statement::VariableDeclaration(prev_var_decl)) = result.last() {
             if var_decl.kind == prev_var_decl.kind {
-                prev_var_decl.declarations.extend(var_decl.declarations.drain(..));
                 state.changed = true;
-                return;
             }
         }
-        result.push(Statement::VariableDeclaration(var_decl));
+        let VariableDeclaration { span, kind, declarations, declare } = var_decl.unbox();
+        for mut decl in declarations {
+            if Self::is_declarator_unused(&decl, ctx) {
+                state.changed = true;
+                if let Some(init) = decl.init.take() {
+                    if init.may_have_side_effects(ctx) {
+                        result.push(ctx.ast.statement_expression(init.span(), init));
+                    }
+                }
+            } else {
+                if let Some(Statement::VariableDeclaration(prev_var_decl)) = result.last_mut() {
+                    if kind == prev_var_decl.kind {
+                        prev_var_decl.declarations.push(decl);
+                        continue;
+                    }
+                }
+                let decls = ctx.ast.vec1(decl);
+                let new_decl = ctx.ast.alloc_variable_declaration(span, kind, decls, declare);
+                result.push(Statement::VariableDeclaration(new_decl));
+            }
+        }
+    }
+
+    fn is_declarator_unused(decl: &VariableDeclarator<'a>, ctx: &mut Ctx<'a, '_>) -> bool {
+        if ctx.state.options.unused == CompressOptionsUnused::Keep {
+            return false;
+        }
+        // It is unsafe to remove if direct eval is involved.
+        if ctx.scoping().root_scope_flags().contains_direct_eval() {
+            return false;
+        }
+        if let BindingPatternKind::BindingIdentifier(ident) = &decl.id.kind {
+            if let Some(symbol_id) = ident.symbol_id.get() {
+                return ctx.scoping().symbol_is_unused(symbol_id);
+            }
+        }
+        false
     }
 
     fn handle_expression_statement(

crates/oxc_minifier/src/peephole/mod.rs

@@ -16,6 +16,8 @@ mod remove_unused_expression;
 mod replace_known_methods;
 mod substitute_alternate_syntax;
 
+use oxc_ast_visit::Visit;
+use oxc_semantic::ReferenceId;
 use rustc_hash::FxHashSet;
 
 use oxc_allocator::Vec;
@@ -99,8 +101,9 @@ impl<'a> PeepholeOptimizations {
 
     #[inline]
     fn is_prev_function_changed(&self) -> bool {
-        let (_, prev_changed, _) = self.current_function.last();
-        *prev_changed
+        true
+        // let (_, prev_changed, _) = self.current_function.last();
+        // *prev_changed
     }
 
     fn enter_program_or_function(&mut self, scope_id: ScopeId) {
@@ -150,8 +153,20 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         self.enter_program_or_function(program.scope_id());
     }
 
-    fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) {
+    fn exit_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
+        let refs_before =
+            ctx.scoping().resolved_references().flatten().copied().collect::<FxHashSet<_>>();
+
         self.exit_program_or_function();
+
+        let mut counter = ReferencesCounter::default();
+        counter.visit_program(program);
+        let refs_after = counter.refs;
+
+        let removed_refs = refs_before.difference(&refs_after);
+        for reference_id_to_remove in removed_refs {
+            ctx.scoping_mut().delete_reference(*reference_id_to_remove);
+        }
     }
 
     fn enter_function(&mut self, func: &mut Function<'a>, _ctx: &mut TraverseCtx<'a>) {
@@ -489,3 +504,16 @@ impl<'a> Traverse<'a, MinifierState<'a>> for DeadCodeElimination {
         self.inner.remove_dead_code_exit_expression(expr, &mut state, &mut ctx);
     }
 }
+
+#[derive(Default)]
+struct ReferencesCounter {
+    refs: FxHashSet<ReferenceId>,
+}
+
+impl<'a> Visit<'a> for ReferencesCounter {
+    fn visit_identifier_reference(&mut self, it: &IdentifierReference<'a>) {
+        if let Some(reference_id) = it.reference_id.get() {
+            self.refs.insert(reference_id);
+        }
+    }
+}

crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs

@@ -1275,11 +1275,11 @@ mod test {
     use crate::{
         CompressOptions,
         options::CompressOptionsKeepNames,
-        tester::{run, test, test_same},
+        tester::{default_options, run, test, test_same},
     };
 
     fn test_same_keep_names(keep_names: CompressOptionsKeepNames, code: &str) {
-        let result = run(code, Some(CompressOptions { keep_names, ..CompressOptions::smallest() }));
+        let result = run(code, Some(CompressOptions { keep_names, ..default_options() }));
         let expected = run(code, None);
         assert_eq!(result, expected, "\nfor source\n{code}\ngot\n{result}");
     }

crates/oxc_minifier/src/tester.rs

@@ -3,7 +3,11 @@ use oxc_codegen::{Codegen, CodegenOptions};
 use oxc_parser::{ParseOptions, Parser};
 use oxc_span::SourceType;
 
-use crate::{CompressOptions, Compressor};
+use crate::{CompressOptions, CompressOptionsUnused, Compressor};
+
+pub fn default_options() -> CompressOptions {
+    CompressOptions { unused: CompressOptionsUnused::Keep, ..CompressOptions::smallest() }
+}
 
 #[track_caller]
 pub fn test_same(source_text: &str) {
@@ -17,7 +21,7 @@ pub fn test_same_options(source_text: &str, options: &CompressOptions) {
 
 #[track_caller]
 pub fn test(source_text: &str, expected: &str) {
-    test_options(source_text, expected, &CompressOptions::smallest());
+    test_options(source_text, expected, &default_options());
 }
 
 #[track_caller]

crates/oxc_minifier/tests/peephole/mod.rs

@@ -5,11 +5,16 @@ mod minimize_exit_points;
 mod oxc;
 mod statement_fusion;
 
-use oxc_minifier::CompressOptions;
+use oxc_minifier::{CompressOptions, CompressOptionsUnused};
 
 #[track_caller]
 fn test(source_text: &str, expected: &str) {
-    let options = CompressOptions { drop_debugger: false, ..CompressOptions::default() };
+    let options = CompressOptions {
+        drop_debugger: false,
+        drop_console: false,
+        unused: CompressOptionsUnused::Keep,
+        ..CompressOptions::smallest()
+    };
     crate::test(source_text, expected, options);
 }
 

crates/oxc_semantic/src/scoping.rs

@@ -370,6 +370,12 @@ impl Scoping {
         });
     }
 
+    /// Delete a reference.
+    pub fn delete_reference(&mut self, reference_id: ReferenceId) {
+        let Some(symbol_id) = self.get_reference(reference_id).symbol_id() else { return };
+        self.delete_resolved_reference(symbol_id, reference_id);
+    }
+
     /// Delete a reference to a symbol.
     ///
     /// # Panics

napi/minify/index.d.ts

@@ -23,8 +23,6 @@ export interface CompressOptions {
    * @default 'esnext'
    */
   target?: 'esnext' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024'
-  /** Keep function / class names. */
-  keepNames?: CompressOptionsKeepNames
   /**
    * Pass true to discard calls to `console.*`.
    *
@@ -37,6 +35,14 @@ export interface CompressOptions {
    * @default true
    */
   dropDebugger?: boolean
+  /**
+   * Drop unreferenced functions and variables.
+   *
+   * Simple direct variable assignments do not count as references unless set to "keep_assign".
+   */
+  unused?: true | false | 'keep_assign'
+  /** Keep function / class names. */
+  keepNames?: CompressOptionsKeepNames
 }
 
 export interface CompressOptionsKeepNames {

napi/minify/src/options.rs

@@ -23,9 +23,6 @@ pub struct CompressOptions {
     )]
     pub target: Option<String>,
 
-    /// Keep function / class names.
-    pub keep_names: Option<CompressOptionsKeepNames>,
-
     /// Pass true to discard calls to `console.*`.
     ///
     /// @default false
@@ -35,12 +32,15 @@ pub struct CompressOptions {
     ///
     /// @default true
     pub drop_debugger: Option<bool>,
-}
 
-impl Default for CompressOptions {
-    fn default() -> Self {
-        Self { target: None, keep_names: None, drop_console: None, drop_debugger: Some(true) }
-    }
+    /// Drop unreferenced functions and variables.
+    ///
+    /// Simple direct variable assignments do not count as references unless set to "keep_assign".
+    #[napi(ts_type = "true | false | 'keep_assign'")]
+    pub unused: Option<String>,
+
+    /// Keep function / class names.
+    pub keep_names: Option<CompressOptionsKeepNames>,
 }
 
 impl TryFrom<&CompressOptions> for oxc_minifier::CompressOptions {
@@ -56,6 +56,8 @@ impl TryFrom<&CompressOptions> for oxc_minifier::CompressOptions {
                 .unwrap_or(default.target),
             drop_console: o.drop_console.unwrap_or(default.drop_console),
             drop_debugger: o.drop_debugger.unwrap_or(default.drop_debugger),
+            // TODO
+            unused: oxc_minifier::CompressOptionsUnused::Keep,
             keep_names: o.keep_names.as_ref().map(Into::into).unwrap_or_default(),
             treeshake: TreeShakeOptions::default(),
         })