perf(semantic): keep a single map of unresolved references

[lucab]

This reworks ScopeTree in order to keep a single (root) map of unresolved references. The SemanticBuilder keeps track of all intermediate ones while walking scopes, and it can get rid of all non-root ones once done.

Ref: oxc-project/backlog#32

[graphite-app]

Your org has enabled the Graphite merge queue for merging into main

Add the label “merge” to the PR and Graphite will automatically add it to the merge queue when it’s ready to merge. Or use the label “hotfix” to add to the merge queue as a hot fix.

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

[lucab]

/cc @overlookmotel

[codspeed-hq]

CodSpeed Performance Report

Merging #4107 will not alter performance

_{Comparing lucab:ups/semantic-scope-root-unresolved-references (c77114a) with main (115ac3b)}

Summary

✅ 29 untouched benchmarks

[Boshen]

Clever! Thank you!

[Boshen]

@lucab Given your recent contributions, I have sent you invitation to the repo with write permission so you can use graphite. https://github.com/oxc-project/oxc/invitations

[lucab]

For reference, I tried to push unresolved_references directly into Semantic (as suggested in oxc-project/backlog#32) but eventually found out that at least the JSX transformer needs to access it through ScopeTree (it doesn't seem to have access to Semantic in its traversing context):

oxc/crates/oxc_transformer/src/react/jsx.rs

Lines 983 to 992 in c3f08ce

	/// Create `IdentifierReference` for var name in current scope which is read from
	fn get_read_identifier_reference<'a>(
	span: Span,
	name: Atom<'a>,
	ctx: &mut TraverseCtx<'a>,
	) -> IdentifierReference<'a> {
	let reference_id =
	ctx.create_reference_in_current_scope(name.to_compact_str(), ReferenceFlag::Read);
	IdentifierReference::new_read(span, name, Some(reference_id))
	}

[overlookmotel]

Nice work @lucab!

I can see potential for one further optimization...

When exiting a scope, UnresolvedReferences for that scope is drained, and then that FxHashMap is never used again. We end up creating a short-lived FxHashMap for every scope.

Instead of unresolved_references being a Vec indexed by scope ID, could it be a stack? When you exit a scope, UnresolvedReferences for that scope would be cleared, but left in unresolved_references. Then when entering next sibling scope, you reuse the same UnresolvedReferences as before. This would reduce allocations, and also you'd mostly be using a FxHashMap which is already warm in cache.

Does that make sense, and do you think it could work/make a difference?

[overlookmotel]

I tried to push unresolved_references directly into Semantic

Personally, I think ScopeTree is the best place for it. Unresolved references could be considered to be the "global scope".