From 563479a5d99203dc5fe03a231d98c3ca61466421 Mon Sep 17 00:00:00 2001 From: sapphi-red <49056869+sapphi-red@users.noreply.github.com> Date: Tue, 2 Sep 2025 00:07:49 +0900 Subject: [PATCH] refactor(minifier): rename SymbolValue to SymbolInformation --- crates/oxc_minifier/src/ctx.rs | 3 +- crates/oxc_minifier/src/peephole/inline.rs | 13 +++++--- crates/oxc_minifier/src/peephole/mod.rs | 4 +-- crates/oxc_minifier/src/state.rs | 6 ++-- crates/oxc_minifier/src/symbol_value.rs | 36 +++++++++++++++------- 5 files changed, 39 insertions(+), 23 deletions(-) diff --git a/crates/oxc_minifier/src/ctx.rs b/crates/oxc_minifier/src/ctx.rs index 9d73156168310..1ac2a17706473 100644 --- a/crates/oxc_minifier/src/ctx.rs +++ b/crates/oxc_minifier/src/ctx.rs @@ -55,8 +55,7 @@ impl<'a> oxc_ecmascript::GlobalContext<'a> for Ctx<'a, '_> { .symbol_id() .and_then(|symbol_id| self.state.symbol_values.get_symbol_value(symbol_id)) .filter(|sv| sv.write_references_count == 0) - .and_then(|sv| sv.initialized_constant.as_ref()) - .cloned() + .and_then(|sv| sv.value.to_constant_value()) } } diff --git a/crates/oxc_minifier/src/peephole/inline.rs b/crates/oxc_minifier/src/peephole/inline.rs index ec08f083f5a24..d901ca19d34f0 100644 --- a/crates/oxc_minifier/src/peephole/inline.rs +++ b/crates/oxc_minifier/src/peephole/inline.rs @@ -5,12 +5,15 @@ use oxc_span::GetSpan; use oxc_traverse::Ancestor; use rustc_hash::FxHashSet; -use crate::{ctx::Ctx, symbol_value::SymbolValue}; +use crate::{ + ctx::Ctx, + symbol_value::{SymbolInformation, SymbolValue}, +}; use super::PeepholeOptimizations; impl<'a> PeepholeOptimizations { - pub fn init_symbol_values(program: &Program<'a>, ctx: &mut Ctx<'a, '_>) { + pub fn init_symbol_information_map(program: &Program<'a>, ctx: &mut Ctx<'a, '_>) { let exported_values = if ctx.source_type().is_script() { FxHashSet::default() } else { @@ -81,8 +84,8 @@ impl<'a> PeepholeOptimizations { } } let scope_id = ctx.scoping().symbol_scope_id(symbol_id); - let value = SymbolValue { - initialized_constant: None, + let value = SymbolInformation { + value: SymbolValue::default(), exported: exported_values.contains(&symbol_id), read_references_count, write_references_count, @@ -121,7 +124,7 @@ impl<'a> PeepholeOptimizations { if symbol_value.write_references_count > 0 { return; } - let Some(cv) = &symbol_value.initialized_constant else { return }; + let SymbolValue::Primitive(cv) = &symbol_value.value else { return }; if symbol_value.read_references_count == 1 || match cv { ConstantValue::Number(n) => n.fract() == 0.0 && *n >= -99.0 && *n <= 999.0, diff --git a/crates/oxc_minifier/src/peephole/mod.rs b/crates/oxc_minifier/src/peephole/mod.rs index f584be25ac057..53756de47c3f4 100644 --- a/crates/oxc_minifier/src/peephole/mod.rs +++ b/crates/oxc_minifier/src/peephole/mod.rs @@ -109,7 +109,7 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations { fn enter_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) { let ctx = &mut Ctx::new(ctx); ctx.state.symbol_values.clear(); - Self::init_symbol_values(program, ctx); + Self::init_symbol_information_map(program, ctx); ctx.state.changed = false; } @@ -423,7 +423,7 @@ impl<'a> Traverse<'a, MinifierState<'a>> for DeadCodeElimination { fn enter_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) { let ctx = &mut Ctx::new(ctx); ctx.state.symbol_values.clear(); - PeepholeOptimizations::init_symbol_values(program, ctx); + PeepholeOptimizations::init_symbol_information_map(program, ctx); ctx.state.changed = false; } diff --git a/crates/oxc_minifier/src/state.rs b/crates/oxc_minifier/src/state.rs index d8ce7a2e6d7ee..29e84a80d0fdd 100644 --- a/crates/oxc_minifier/src/state.rs +++ b/crates/oxc_minifier/src/state.rs @@ -4,7 +4,7 @@ use rustc_hash::FxHashMap; use oxc_span::SourceType; use oxc_syntax::symbol::SymbolId; -use crate::{CompressOptions, symbol_value::SymbolValues}; +use crate::{CompressOptions, symbol_value::SymbolInformationMap}; pub struct MinifierState<'a> { pub source_type: SourceType, @@ -14,7 +14,7 @@ pub struct MinifierState<'a> { /// The return value of function declarations that are pure pub pure_functions: FxHashMap>>, - pub symbol_values: SymbolValues<'a>, + pub symbol_values: SymbolInformationMap<'a>, pub changed: bool, } @@ -25,7 +25,7 @@ impl MinifierState<'_> { source_type, options, pure_functions: FxHashMap::default(), - symbol_values: SymbolValues::default(), + symbol_values: SymbolInformationMap::default(), changed: false, } } diff --git a/crates/oxc_minifier/src/symbol_value.rs b/crates/oxc_minifier/src/symbol_value.rs index af2d31f046696..2a521d5f5fbdb 100644 --- a/crates/oxc_minifier/src/symbol_value.rs +++ b/crates/oxc_minifier/src/symbol_value.rs @@ -3,11 +3,23 @@ use rustc_hash::FxHashMap; use oxc_ecmascript::constant_evaluation::ConstantValue; use oxc_syntax::{scope::ScopeId, symbol::SymbolId}; +#[derive(Debug, Default)] +pub enum SymbolValue<'a> { + /// Initialized primitive constant value evaluated from expressions. + Primitive(ConstantValue<'a>), + #[default] + Unknown, +} + +impl<'a> SymbolValue<'a> { + pub fn to_constant_value(&self) -> Option> { + if let SymbolValue::Primitive(cv) = self { Some(cv.clone()) } else { None } + } +} + #[derive(Debug)] -pub struct SymbolValue<'a> { - /// Initialized constant value evaluated from expressions. - /// `None` when the value is not a constant evaluated value. - pub initialized_constant: Option>, +pub struct SymbolInformation<'a> { + pub value: SymbolValue<'a>, /// Symbol is exported. pub exported: bool, @@ -20,16 +32,16 @@ pub struct SymbolValue<'a> { } #[derive(Debug, Default)] -pub struct SymbolValues<'a> { - values: FxHashMap>, +pub struct SymbolInformationMap<'a> { + values: FxHashMap>, } -impl<'a> SymbolValues<'a> { +impl<'a> SymbolInformationMap<'a> { pub fn clear(&mut self) { self.values.clear(); } - pub fn init_value(&mut self, symbol_id: SymbolId, symbol_value: SymbolValue<'a>) { + pub fn init_value(&mut self, symbol_id: SymbolId, symbol_value: SymbolInformation<'a>) { self.values.insert(symbol_id, symbol_value); } @@ -38,11 +50,13 @@ impl<'a> SymbolValues<'a> { symbol_id: SymbolId, symbol_value: Option>, ) { - let value = self.values.get_mut(&symbol_id).expect("symbol value must exist"); - value.initialized_constant = symbol_value; + let info = self.values.get_mut(&symbol_id).expect("symbol value must exist"); + if let Some(constant) = symbol_value { + info.value = SymbolValue::Primitive(constant); + } } - pub fn get_symbol_value(&self, symbol_id: SymbolId) -> Option<&SymbolValue<'a>> { + pub fn get_symbol_value(&self, symbol_id: SymbolId) -> Option<&SymbolInformation<'a>> { self.values.get(&symbol_id) } }