refactor(minifier): port esbuild's mangleStmts

[Boshen]

No description provided.

[graphite-app]

How to use the Graphite Merge Queue

Add either label to this PR to merge it via the merge queue:

• 0-merge - adds this PR to the back of the merge queue
• hotfix - for urgent hot fixes, skip the queue and merge this PR next

You must have a Graphite account in order to use the merge queue. Sign up using this link.

An organization admin has enabled the Graphite Merge Queue in this repository.

Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.

[codspeed-hq]

CodSpeed Performance Report

Merging #8770 will improve performances by 13.09%

_{Comparing 01-28-refactor_minifier_port_esbuild_s_manglestmts_ (033b55f) with main (249895f)}

Summary

⚡ 2 improvements
✅ 31 untouched benchmarks

Benchmarks breakdown

	Benchmark	BASE	HEAD	Change
⚡	minifier[antd.js]	160.7 ms	155.6 ms	+3.27%
⚡	minifier[typescript.js]	305.9 ms	270.5 ms	+13.09%

[Boshen]

@sapphi-red Please take a look, The previous google closure compiler architecture is not holding up well :-/

The current direction for performance is 1 AST pass with lots of small "minimize expression" calls when new expressions are created ... we'll get there!

[sapphi-red]

Great! I left some comments

[sapphi-red]

I guess this case is mostly handled by

oxc/crates/oxc_minifier/src/peephole/minimize_statements.rs

Lines 280 to 291 in 033b55f

	Statement::ReturnStatement(mut ret_stmt) => {
	if let Some(Statement::ExpressionStatement(prev_expr_stmt)) = result.last_mut() {
	if let Some(argument) = &mut ret_stmt.argument {
	let a = &mut prev_expr_stmt.expression;
	*argument = Self::join_sequence(a, argument, ctx);
	result.pop();
	self.mark_current_function_as_changed();
	}
	}
	result.push(Statement::ReturnStatement(ret_stmt));
	*is_control_flow_dead = true;
	}

When is this code needed?

[sapphi-red]

Similar to the previous question, I wonder if this can be done inside self.minimize_statement by running self.minimize_statement when the last item of result changed.

[sapphi-red]

(I guess you're aware of it, but in case) I think ForInStatement, LabeledStatement, BlockStatement is missing here.

oxc/crates/oxc_minifier/src/peephole/statement_fusion.rs

Lines 70 to 80 in 29417dd

	// Avoid cases where we have for(var x = foo() in a) { ....
	Statement::ForInStatement(for_in_stmt) => {
	!matches!(&for_in_stmt.left, ForStatementLeft::VariableDeclaration(_))
	}
	Statement::LabeledStatement(labeled_stmt) => {
	Self::is_fusable_control_statement(&labeled_stmt.body)
	}
	Statement::BlockStatement(block) => {
	can_merge_block_stmt(block)
	&& block.body.first().is_some_and(Self::is_fusable_control_statement)
	}

oxc/crates/oxc_minifier/src/peephole/statement_fusion.rs

Lines 134 to 150 in 29417dd

	Statement::ForInStatement(for_stmt) => &mut for_stmt.right,
	Statement::LabeledStatement(labeled_stmt) => {
	Self::fuse_expression_into_control_flow_statement(
	&mut labeled_stmt.body,
	exprs,
	ctx,
	);
	return;
	}
	Statement::BlockStatement(block) => {
	Self::fuse_expression_into_control_flow_statement(
	block.body.first_mut().unwrap(),
	exprs,
	ctx,
	);
	return;
	}

Maybe BlockStatement should be handled in a different place though.

[sapphi-red]

(I guess you're aware of it, but in case) I think merging VariableDeclaration + ForInStatement/ForOfStatement is missing too.

oxc/crates/oxc_minifier/src/peephole/collapse_variable_declarations.rs

Lines 177 to 215 in 0fcff20

	fn collapse_var_into_for_in_or_for_of(
	&mut self,
	i: usize,
	stmts: &mut Vec<'a, Statement<'a>>,
	ctx: Ctx<'a, '_>,
	) {
	if let Statement::VariableDeclaration(decl) = &stmts[i] {
	if decl.kind.is_var()
	&& decl.declarations.len() == 1
	&& decl.declarations[0].init.is_none()
	{
	if let BindingPatternKind::BindingIdentifier(binding) =
	&decl.declarations[0].id.kind
	{
	if let ForStatementLeft::AssignmentTargetIdentifier(target) =
	match &stmts[i + 1] {
	Statement::ForInStatement(stmt) => &stmt.left,
	Statement::ForOfStatement(stmt) => &stmt.left,
	_ => unreachable!(),
	}
	{
	if binding.name == target.name {
	let var_stmt = ctx.ast.move_statement(&mut stmts[i]);
	let Statement::VariableDeclaration(var) = var_stmt else {
	unreachable!()
	};
	let left = match &mut stmts[i + 1] {
	Statement::ForInStatement(stmt) => &mut stmt.left,
	Statement::ForOfStatement(stmt) => &mut stmt.left,
	_ => unreachable!(),
	};
	*left = ForStatementLeft::VariableDeclaration(var);
	self.mark_current_function_as_changed();
	}
	}
	}
	}
	}
	}