Allow per AST Node Ids

[bmeck]

Currently the Semantic pass creates specialized ids such as symbol_id and reference_id that are customized and only generated when encountering the relevant type of data. However, a large variety of alternative passes such as type association and narrowing for the minifier would like to associate data with lots of kinds of nodes (function usages of features like this, expression constant result+effects, etc.).

Instead of having intrusive PR changes to allow for this, it would be ideal to allow lazily generation of identifiers for all AST Nodes. This would allow for passes to share the identifiers as well.

Per storage and existence check concerns, this change would bloat the storage of AST Nodes with a lazy identifier, but we already have to do existence checks for the Cell<Option<...>> approach.

My suggestion is that we enable lazy identifier generation for each kind of AST Node and allow multiple passes to use this to associate like:

let r#type = typereader.types().compute_if_absent(node.node_id)
let value = ast_evaluator.constant_results().compute_if_absent(node.node_id)
if r#type.satisfied_by(value) { /*...*/ }

[TzviPM]

Don't we store ast nodes in a bumpalo arena? Can we just use their index as an id for the node to avoid the idea of a "lazy" id. My concern with lazy ids is it will cause code that needs an id to have to either branch or risk panic. Either case will lead to a performance degredation.

[Boshen]

We currently keep a immutable tree after the first pass

oxc/crates/oxc_semantic/src/node.rs

Lines 47 to 52 in 018675c

	/// Untyped AST nodes flattened into an vec
	#[derive(Debug, Default)]
	pub struct AstNodes<'a> {
	nodes: IndexVec<AstNodeId, AstNode<'a>>,
	parent_ids: IndexVec<AstNodeId, Option<AstNodeId>>,
	}

Perhaps need to make this data structure mutable so that newly created ast nodes can be tracked after the transformer pass.

[bmeck]

Yes, one of my main interests is in newly created nodes.

[Boshen]

You may want to take a look at my TypeScript type inference port: https://gist.github.com/Boshen/d189de0fe0720a30c5182cb666e3e9a5

There is a workaround where I used the ast node spans as index lookups:

pub span_to_node: FxHashMap<Span, AstNodeId>

You may want to start with this approach and see whether it works or not.

This lookup works for all AST nodes except for ({ ident }) where ident is both a reference and a binding.

So you may want to create different look up tables for different purposes.

[bmeck]

This doesn't seem viable for dynamically generated AST nodes where they don't have associated spans, that is at least one of the main things the minifier desires to use the Ids for. I did think of this previously but threw out the idea as it makes things both confusing and can be incorrect when you want to store things that have the same span E.G. expression statement vs expression.

[Boshen]

Continue in #5689