feat(semantics): collect symbols used for function / class names

[sapphi-red]

Collect symbols that are used for function / class names so that we can use this information in the mangler.

[sapphi-red]

• feat(mangler): support keep_names option #9873
• feat(semantics): collect symbols used for function / class names #9872 👈 (View in Graphite)
• main

---

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.

This stack of pull requests is managed by Graphite. Learn more about stacking.

[codspeed-hq]

CodSpeed Performance Report

Merging #9872 will not alter performance

_{Comparing 03-18-feat_semantics_collect_symbols_used_for_function___class_names (af0a969) with main (ecdfe2e)}

Summary

✅ 33 untouched benchmarks

[overlookmotel]

My concern about this change is that this is more semantic data that we need to keep in sync with AST changes in transformer. That's quite a struggle already!

Is this necessary to achieve the keepNames option? Could we maybe achieve the same thing with SymbolFlags?

[sapphi-red]

Is this necessary to achieve the keepNames option? Could we maybe achieve the same thing with SymbolFlags?

It isn't necessary; the other option I can think of is to check the parent node in the mangler by calling nodes().parent_node(node) for each symbol declaration and references.
Current SymbolFlags does not contain the needed information so it cannot be used.

[camc314]

i think

diff --git a/crates/oxc_mangler/src/lib.rs b/crates/oxc_mangler/src/lib.rs
index d43bea1b8..adb8a087e 100644
--- a/crates/oxc_mangler/src/lib.rs
+++ b/crates/oxc_mangler/src/lib.rs
@@ -388,6 +388,14 @@ impl Mangler {
             if is_special_name(scoping.symbol_name(symbol_id)) {
                 continue;
             }
+
+            let symbol_flags: oxc_semantic::SymbolFlags = scoping.symbol_flags(symbol_id);
+
+            if self.options.keep_names.function && symbol_flags.is_function()
+                || self.options.keep_names.class && symbol_flags.is_class()
+            {
+                continue;
+            }
             let index = slot;
             frequencies[index].slot = slot;
             frequencies[index].frequency += scoping.get_resolved_reference_ids(symbol_id).len();

should work

iirc, i tried this a very long time ago and that diff seemed to have the desired effect

[sapphi-red]

does:
...
not work?

I tried this long time ago

I think it does not work because foo does not have SymbolFlags(Function).
https://playground.oxc.rs/#eNo9jz9rxDAMxb+K0dRChrbQJdCt3NrSrrcojnwYHCnIdtoj5LuffTln0h+k33tvBQs9LKjGiZgP4zLb5IXN07NZz2zMmTfoQKBfQTPXEq+c8B/6pJk6CJ5T66OVmY7hOg0S2pQUOTrRCXqHIdLWwYwaSSsRQ5C/H0pZ+Sun6Ec6PWy091mp3C70jUoc921BVPE7ovSHws5MqBcqzoDi28vre8ngowRMNH6SDahY8YXU3FgZ6UL3gMQ4BPqVrJYmnA+1ybN3vulZ4aQSTsV6fVpIB4kl/Q7cthuy33s7

[sapphi-red]

the other option I can think of is to check the parent node in the mangler by calling nodes().parent_node(node) for each symbol declaration and references.

On second thought, this sounds better. Also found this code which does a similar thing.

oxc/crates/oxc_linter/src/rules/eslint/func_names.rs

Lines 170 to 225 in ecdfe2e

	match parent_node.kind() {
	AstKind::VariableDeclarator(declarator) => {
	matches!(declarator.id.kind, BindingPatternKind::BindingIdentifier(_))
	&& matches!(declarator.init.as_ref().unwrap(), Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::ObjectProperty(property) => {
	matches!(&property.value, Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::PropertyDefinition(definition) => {
	matches!(&definition.value.as_ref().unwrap(), Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::AssignmentExpression(expression) => {
	matches!(expression.left, AssignmentTarget::AssignmentTargetIdentifier(_))
	&& matches!(&expression.right, Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::AssignmentTargetWithDefault(target) => {
	matches!(target.binding, AssignmentTarget::AssignmentTargetIdentifier(_))
	&& matches!(&target.init, Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::AssignmentPattern(pattern) => {
	matches!(pattern.left.kind, BindingPatternKind::BindingIdentifier(_))
	&& matches!(&pattern.right, Expression::FunctionExpression(function_expression)
	if get_function_identifier(function_expression) == get_function_identifier(function)
	)
	}
	AstKind::ObjectAssignmentTarget(target) => {
	for property in &target.properties {
	let AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(identifier) =
	property
	else {
	continue;
	};
	let Expression::FunctionExpression(function_expression) =
	&identifier.init.as_ref().unwrap()
	else {
	continue;
	};
	if get_function_identifier(function_expression) == get_function_identifier(function)
	{
	return true;
	}
	}
	false
	}
	_ => false,