regular_expression: implement visitor pattern for regex AST

[camchenry]

With the regex parser completed, we have now started using oxc_regular_expression in the linter for parsing patterns instead of handwritten pattern matching and parsing code.

However, it is difficult to traverse the regex AST and visit each node (term/disjunction/alternative/etc.). We should implement the visitor pattern for the regex AST, so it is easier to write some code that visits every node.

Ideally, we should be able to replace code like this:

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

Lines 119 to 146 in 74d8714

	visit_terms(pattern, &mut |term| {
	if let Term::Quantifier(_) = term {
	in_quantifier = true;
	return;
	}
	let Term::Character(ch) = term else {
	return;
	};
	if in_quantifier {
	in_quantifier = false;
	return;
	}
	if ch.value != u32::from(b' ') {
	return;
	}
	if let Some(ref mut space_span) = last_space_span {
	// If this is consecutive with the last space, extend it
	if space_span.end == ch.span.start {
	space_span.end = ch.span.end;
	}
	// If it is not consecutive, and the last space is only one space, move it up
	else if space_span.size() == 1 {
	last_space_span.replace(ch.span);
	}
	} else {
	last_space_span = Some(ch.span);
	}
	});

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

Lines 171 to 206 in 74d8714

	/// Calls the given closure on every [`Term`] in the [`Pattern`].
	fn visit_terms<'a, F: FnMut(&'a Term<'a>)>(pattern: &'a Pattern, f: &mut F) {
	visit_terms_disjunction(&pattern.body, f);
	}
	/// Calls the given closure on every [`Term`] in the [`Disjunction`].
	fn visit_terms_disjunction<'a, F: FnMut(&'a Term<'a>)>(disjunction: &'a Disjunction, f: &mut F) {
	for alternative in &disjunction.body {
	visit_terms_alternative(alternative, f);
	}
	}
	/// Calls the given closure on every [`Term`] in the [`Alternative`].
	fn visit_terms_alternative<'a, F: FnMut(&'a Term<'a>)>(alternative: &'a Alternative, f: &mut F) {
	for term in &alternative.body {
	match term {
	Term::LookAroundAssertion(lookaround) => {
	f(term);
	visit_terms_disjunction(&lookaround.body, f);
	}
	Term::Quantifier(quant) => {
	f(term);
	f(&quant.body);
	}
	Term::CapturingGroup(group) => {
	f(term);
	visit_terms_disjunction(&group.body, f);
	}
	Term::IgnoreGroup(group) => {
	f(term);
	visit_terms_disjunction(&group.body, f);
	}
	_ => f(term),
	}
	}
	}