diff --git a/crates/oxc_ast/src/visit.rs b/crates/oxc_ast/src/visit.rs
index ef3cfc6c3..e99485565 100644
--- a/crates/oxc_ast/src/visit.rs
+++ b/crates/oxc_ast/src/visit.rs
@@ -9,17 +9,17 @@ use oxc_allocator::Vec;
 use crate::{ast::*, ast_kind::AstKind};
 
 pub trait Visit<'a>: Sized {
-    fn enter_span(&mut self, _kind: AstKind<'a>) {}
-    fn leave_span(&mut self, _kind: AstKind<'a>) {}
+    fn enter_node(&mut self, _kind: AstKind<'a>) {}
+    fn leave_node(&mut self, _kind: AstKind<'a>) {}
 
     fn visit_program(&mut self, program: &'a Program<'a>) {
         let kind = AstKind::Program(program);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for directive in &program.directives {
             self.visit_directive(directive);
         }
         self.visit_statements(&program.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Statement ---------- */
@@ -62,59 +62,59 @@ pub trait Visit<'a>: Sized {
 
     fn visit_block_statement(&mut self, stmt: &'a BlockStatement<'a>) {
         let kind = AstKind::BlockStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_statements(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_break_statement(&mut self, stmt: &'a BreakStatement) {
         let kind = AstKind::BreakStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(break_target) = &stmt.label {
             self.visit_label_identifier(break_target);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_continue_statement(&mut self, stmt: &'a ContinueStatement) {
         let kind = AstKind::ContinueStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(continue_target) = &stmt.label {
             self.visit_label_identifier(continue_target);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_debugger_statement(&mut self, stmt: &'a DebuggerStatement) {
         let kind = AstKind::DebuggerStatement(stmt);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_do_while_statement(&mut self, stmt: &'a DoWhileStatement<'a>) {
         let kind = AstKind::DoWhileStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_statement(&stmt.body);
         self.visit_expression(&stmt.test);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_empty_statement(&mut self, stmt: &'a EmptyStatement) {
         let kind = AstKind::EmptyStatement(stmt);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_expression_statement(&mut self, stmt: &'a ExpressionStatement<'a>) {
         let kind = AstKind::ExpressionStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.expression);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_for_statement(&mut self, stmt: &'a ForStatement<'a>) {
         let kind = AstKind::ForStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(init) = &stmt.init {
             self.visit_for_statement_init(init);
         }
@@ -125,37 +125,37 @@ pub trait Visit<'a>: Sized {
             self.visit_expression(update);
         }
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_for_statement_init(&mut self, init: &'a ForStatementInit<'a>) {
         let kind = AstKind::ForStatementInit(init);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match init {
             ForStatementInit::VariableDeclaration(decl) => {
                 self.visit_variable_declaration(decl);
             }
             ForStatementInit::Expression(expr) => self.visit_expression(expr),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_for_in_statement(&mut self, stmt: &'a ForInStatement<'a>) {
         let kind = AstKind::ForInStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_for_statement_left(&stmt.left);
         self.visit_expression(&stmt.right);
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_for_of_statement(&mut self, stmt: &'a ForOfStatement<'a>) {
         let kind = AstKind::ForOfStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_for_statement_left(&stmt.left);
         self.visit_expression(&stmt.right);
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_for_statement_left(&mut self, left: &'a ForStatementLeft<'a>) {
@@ -169,62 +169,62 @@ pub trait Visit<'a>: Sized {
 
     fn visit_if_statement(&mut self, stmt: &'a IfStatement<'a>) {
         let kind = AstKind::IfStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.test);
         self.visit_statement(&stmt.consequent);
         if let Some(alternate) = &stmt.alternate {
             self.visit_statement(alternate);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_labeled_statement(&mut self, stmt: &'a LabeledStatement<'a>) {
         let kind = AstKind::LabeledStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_label_identifier(&stmt.label);
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_return_statement(&mut self, stmt: &'a ReturnStatement<'a>) {
         let kind = AstKind::ReturnStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(arg) = &stmt.argument {
             self.visit_expression(arg);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_switch_statement(&mut self, stmt: &'a SwitchStatement<'a>) {
         let kind = AstKind::SwitchStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.discriminant);
         for case in &stmt.cases {
             self.visit_switch_case(case);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_switch_case(&mut self, case: &'a SwitchCase<'a>) {
         let kind = AstKind::SwitchCase(case);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(expr) = &case.test {
             self.visit_expression(expr);
         }
         self.visit_statements(&case.consequent);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_throw_statement(&mut self, stmt: &'a ThrowStatement<'a>) {
         let kind = AstKind::ThrowStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_try_statement(&mut self, stmt: &'a TryStatement<'a>) {
         let kind = AstKind::TryStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_block_statement(&stmt.block);
         if let Some(handler) = &stmt.handler {
             self.visit_catch_clause(handler);
@@ -232,75 +232,75 @@ pub trait Visit<'a>: Sized {
         if let Some(finalizer) = &stmt.finalizer {
             self.visit_finally_clause(finalizer);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_catch_clause(&mut self, clause: &'a CatchClause<'a>) {
         let kind = AstKind::CatchClause(clause);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(param) = &clause.param {
             self.visit_pattern(param);
         }
         self.visit_statements(&clause.body.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_finally_clause(&mut self, clause: &'a BlockStatement<'a>) {
         let kind = AstKind::FinallyClause(clause);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_block_statement(clause);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_while_statement(&mut self, stmt: &'a WhileStatement<'a>) {
         let kind = AstKind::WhileStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.test);
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_with_statement(&mut self, stmt: &'a WithStatement<'a>) {
         let kind = AstKind::WithStatement(stmt);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&stmt.object);
         self.visit_statement(&stmt.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_directive(&mut self, directive: &'a Directive<'a>) {
         let kind = AstKind::Directive(directive);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_string_literal(&directive.expression);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Declaration ---------- */
 
     fn visit_variable_declaration(&mut self, decl: &'a VariableDeclaration<'a>) {
         let kind = AstKind::VariableDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for declarator in &decl.declarations {
             self.visit_variable_declarator(declarator);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_variable_declarator(&mut self, declarator: &'a VariableDeclarator<'a>) {
         let kind = AstKind::VariableDeclarator(declarator);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_pattern(&declarator.id);
         if let Some(init) = &declarator.init {
             self.visit_expression(init);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Function ---------- */
 
     fn visit_function(&mut self, func: &'a Function<'a>) {
         let kind = AstKind::Function(func);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(ident) = &func.id {
             self.visit_binding_identifier(ident);
         }
@@ -314,52 +314,52 @@ pub trait Visit<'a>: Sized {
         if let Some(annotation) = &func.return_type {
             self.visit_ts_type_annotation(annotation);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_function_body(&mut self, body: &'a FunctionBody<'a>) {
         let kind = AstKind::FunctionBody(body);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for directive in &body.directives {
             self.visit_directive(directive);
         }
         self.visit_statements(&body.statements);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_formal_parameters(&mut self, params: &'a FormalParameters<'a>) {
         let kind = AstKind::FormalParameters(params);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for param in &params.items {
             self.visit_formal_parameter(param);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_formal_parameter(&mut self, param: &'a FormalParameter<'a>) {
         let kind = AstKind::FormalParameter(param);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(decorators) = &param.decorators {
             for decorator in decorators {
                 self.visit_decorator(decorator);
             }
         }
         self.visit_pattern(&param.pattern);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Class ---------- */
 
     fn visit_decorator(&mut self, decorator: &'a Decorator<'a>) {
         let kind = AstKind::Decorator(decorator);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&decorator.expression);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_class(&mut self, class: &'a Class<'a>) {
         let kind = AstKind::Class(class);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(decorators) = &class.decorators {
             for decorator in decorators {
                 self.visit_decorator(decorator);
@@ -379,14 +379,14 @@ pub trait Visit<'a>: Sized {
             self.visit_ts_type_parameter_instantiation(super_parameters);
         }
         self.visit_class_body(&class.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_class_heritage(&mut self, expr: &'a Expression<'a>) {
         let kind = AstKind::ClassHeritage(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(expr);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_class_body(&mut self, body: &'a ClassBody<'a>) {
@@ -413,14 +413,14 @@ pub trait Visit<'a>: Sized {
 
     fn visit_static_block(&mut self, block: &'a StaticBlock<'a>) {
         let kind = AstKind::StaticBlock(block);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_statements(&block.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_method_definition(&mut self, def: &'a MethodDefinition<'a>) {
         let kind = AstKind::MethodDefinition(def);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(decorators) = &def.decorators {
             for decorator in decorators {
                 self.visit_decorator(decorator);
@@ -428,12 +428,12 @@ pub trait Visit<'a>: Sized {
         }
         self.visit_property_key(&def.key);
         self.visit_function(&def.value);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_property_definition(&mut self, def: &'a PropertyDefinition<'a>) {
         let kind = AstKind::PropertyDefinition(def);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(decorators) = &def.decorators {
             for decorator in decorators {
                 self.visit_decorator(decorator);
@@ -446,7 +446,7 @@ pub trait Visit<'a>: Sized {
         if let Some(annotation) = &def.type_annotation {
             self.visit_ts_type_annotation(annotation);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Expression ---------- */
@@ -510,73 +510,73 @@ pub trait Visit<'a>: Sized {
 
     fn visit_meta_property(&mut self, meta: &'a MetaProperty) {
         let kind = AstKind::MetaProperty(meta);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_array_expression(&mut self, expr: &'a ArrayExpression<'a>) {
         let kind = AstKind::ArrayExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for elem in expr.elements.iter().flatten() {
             self.visit_argument(elem);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_argument(&mut self, arg: &'a Argument<'a>) {
         let kind = AstKind::Argument(arg);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match arg {
             Argument::SpreadElement(spread) => self.visit_spread_element(spread),
             Argument::Expression(expr) => self.visit_expression(expr),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_spread_element(&mut self, elem: &'a SpreadElement<'a>) {
         let kind = AstKind::SpreadElement(elem);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&elem.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_assignment_expression(&mut self, expr: &'a AssignmentExpression<'a>) {
         let kind = AstKind::AssignmentExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_assignment_target(&expr.left);
         self.visit_expression(&expr.right);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_arrow_expression(&mut self, expr: &'a ArrowExpression<'a>) {
         let kind = AstKind::ArrowExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_formal_parameters(&expr.params);
         self.visit_function_body(&expr.body);
         if let Some(parameters) = &expr.type_parameters {
             self.visit_ts_type_parameter_declaration(parameters);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_await_expression(&mut self, expr: &'a AwaitExpression<'a>) {
         let kind = AstKind::AwaitExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_binary_expression(&mut self, expr: &'a BinaryExpression<'a>) {
         let kind = AstKind::BinaryExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.left);
         self.visit_expression(&expr.right);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_call_expression(&mut self, expr: &'a CallExpression<'a>) {
         let kind = AstKind::CallExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for arg in &expr.arguments {
             self.visit_argument(arg);
         }
@@ -584,7 +584,7 @@ pub trait Visit<'a>: Sized {
         if let Some(parameters) = &expr.type_parameters {
             self.visit_ts_type_parameter_instantiation(parameters);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_chain_expression(&mut self, expr: &'a ChainExpression<'a>) {
@@ -600,11 +600,11 @@ pub trait Visit<'a>: Sized {
 
     fn visit_conditional_expression(&mut self, expr: &'a ConditionalExpression<'a>) {
         let kind = AstKind::ConditionalExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.test);
         self.visit_expression(&expr.consequent);
         self.visit_expression(&expr.alternate);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_import_expression(&mut self, expr: &'a ImportExpression<'a>) {
@@ -616,15 +616,15 @@ pub trait Visit<'a>: Sized {
 
     fn visit_logical_expression(&mut self, expr: &'a LogicalExpression<'a>) {
         let kind = AstKind::LogicalExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.left);
         self.visit_expression(&expr.right);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_member_expression(&mut self, expr: &'a MemberExpression<'a>) {
         let kind = AstKind::MemberExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match expr {
             MemberExpression::ComputedMemberExpression(expr) => {
                 self.visit_computed_member_expression(expr);
@@ -636,7 +636,7 @@ pub trait Visit<'a>: Sized {
                 self.visit_private_field_expression(expr);
             }
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_computed_member_expression(&mut self, expr: &'a ComputedMemberExpression<'a>) {
@@ -656,7 +656,7 @@ pub trait Visit<'a>: Sized {
 
     fn visit_new_expression(&mut self, expr: &'a NewExpression<'a>) {
         let kind = AstKind::NewExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.callee);
         if let Some(parameters) = &expr.type_parameters {
             self.visit_ts_type_parameter_instantiation(parameters);
@@ -664,16 +664,16 @@ pub trait Visit<'a>: Sized {
         for arg in &expr.arguments {
             self.visit_argument(arg);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_object_expression(&mut self, expr: &'a ObjectExpression<'a>) {
         let kind = AstKind::ObjectExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for prop in &expr.properties {
             self.visit_object_property(prop);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn enter_object_expression(&mut self, _expr: &'a ObjectExpression<'a>) {}
@@ -687,38 +687,38 @@ pub trait Visit<'a>: Sized {
 
     fn visit_property(&mut self, prop: &'a Property<'a>) {
         let kind = AstKind::Property(prop);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_property_key(&prop.key);
         self.visit_property_value(&prop.value);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_property_key(&mut self, key: &'a PropertyKey<'a>) {
         let kind = AstKind::PropertyKey(key);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match key {
             PropertyKey::Identifier(ident) => self.visit_identifier_name(ident),
             PropertyKey::PrivateIdentifier(ident) => self.visit_private_identifier(ident),
             PropertyKey::Expression(expr) => self.visit_expression(expr),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_property_value(&mut self, value: &'a PropertyValue<'a>) {
         let kind = AstKind::PropertyValue(value);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match value {
             PropertyValue::Pattern(pat) => self.visit_pattern(pat),
             PropertyValue::Expression(expr) => self.visit_expression(expr),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_parenthesized_expression(&mut self, expr: &'a ParenthesizedExpression<'a>) {
         let kind = AstKind::ParenthesizedExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.expression);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_private_in_expression(&mut self, expr: &'a PrivateInExpression<'a>) {
@@ -728,59 +728,59 @@ pub trait Visit<'a>: Sized {
 
     fn visit_sequence_expression(&mut self, expr: &'a SequenceExpression<'a>) {
         let kind = AstKind::SequenceExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for expr in &expr.expressions {
             self.visit_expression(expr);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_tagged_template_expression(&mut self, expr: &'a TaggedTemplateExpression<'a>) {
         let kind = AstKind::TaggedTemplateExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.tag);
         self.visit_template_literal(&expr.quasi);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_this_expression(&mut self, expr: &'a ThisExpression) {
         let kind = AstKind::ThisExpression(expr);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_unary_expression(&mut self, expr: &'a UnaryExpression<'a>) {
         let kind = AstKind::UnaryExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_update_expression(&mut self, expr: &'a UpdateExpression<'a>) {
         let kind = AstKind::UpdateExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_simple_assignment_target(&expr.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_yield_expression(&mut self, expr: &'a YieldExpression<'a>) {
         let kind = AstKind::YieldExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(argument) = &expr.argument {
             self.visit_expression(argument);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_super(&mut self, expr: &'a Super) {
         let kind = AstKind::Super(expr);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_assignment_target(&mut self, target: &'a AssignmentTarget<'a>) {
         let kind = AstKind::AssignmentTarget(target);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match target {
             AssignmentTarget::SimpleAssignmentTarget(target) => {
                 self.visit_simple_assignment_target(target);
@@ -789,12 +789,12 @@ pub trait Visit<'a>: Sized {
                 self.visit_assignment_target_pattern(pat);
             }
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_simple_assignment_target(&mut self, target: &'a SimpleAssignmentTarget<'a>) {
         let kind = AstKind::SimpleAssignmentTarget(target);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match target {
             SimpleAssignmentTarget::AssignmentTargetIdentifier(ident) => {
                 self.visit_identifier_reference(ident);
@@ -812,7 +812,7 @@ pub trait Visit<'a>: Sized {
                 self.visit_expression(&expr.expression);
             }
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_assignment_target_pattern(&mut self, pat: &'a AssignmentTargetPattern<'a>) {
@@ -854,10 +854,10 @@ pub trait Visit<'a>: Sized {
         target: &'a AssignmentTargetWithDefault<'a>,
     ) {
         let kind = AstKind::AssignmentTargetWithDefault(target);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_assignment_target(&target.binding);
         self.visit_expression(&target.init);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_object_assignment_target(&mut self, target: &'a ObjectAssignmentTarget<'a>) {
@@ -909,18 +909,18 @@ pub trait Visit<'a>: Sized {
 
     fn visit_jsx_opening_element(&mut self, elem: &'a JSXOpeningElement<'a>) {
         let kind = AstKind::JSXOpeningElement(elem);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_jsx_element_name(&elem.name);
         for attribute in &elem.attributes {
             self.visit_jsx_attribute_item(attribute);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_jsx_element_name(&mut self, name: &'a JSXElementName<'a>) {
         let kind = AstKind::JSXElementName(name);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_jsx_attribute_item(&mut self, item: &'a JSXAttributeItem<'a>) {
@@ -1003,17 +1003,17 @@ pub trait Visit<'a>: Sized {
 
     fn visit_binding_identifier(&mut self, ident: &'a BindingIdentifier) {
         let kind = AstKind::BindingIdentifier(ident);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_object_pattern(&mut self, pat: &'a ObjectPattern<'a>) {
         let kind = AstKind::ObjectPattern(pat);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for prop in &pat.properties {
             self.visit_object_pattern_property(prop);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_object_pattern_property(&mut self, prop: &'a ObjectPatternProperty<'a>) {
@@ -1025,102 +1025,102 @@ pub trait Visit<'a>: Sized {
 
     fn visit_array_pattern(&mut self, pat: &'a ArrayPattern<'a>) {
         let kind = AstKind::ArrayPattern(pat);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for pat in pat.elements.iter().flatten() {
             self.visit_pattern(pat);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_rest_element(&mut self, pat: &'a RestElement<'a>) {
         let kind = AstKind::RestElement(pat);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_pattern(&pat.argument);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_assignment_pattern(&mut self, pat: &'a AssignmentPattern<'a>) {
         let kind = AstKind::AssignmentPattern(pat);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_pattern(&pat.left);
         self.visit_expression(&pat.right);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Identifier ---------- */
 
     fn visit_identifier_reference(&mut self, ident: &'a IdentifierReference) {
         let kind = AstKind::IdentifierReference(ident);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_private_identifier(&mut self, ident: &'a PrivateIdentifier) {
         let kind = AstKind::PrivateIdentifier(ident);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_label_identifier(&mut self, ident: &'a LabelIdentifier) {
         let kind = AstKind::LabelIdentifier(ident);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_identifier_name(&mut self, ident: &'a IdentifierName) {
         let kind = AstKind::IdentifierName(ident);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     /* ----------  Literal ---------- */
 
     fn visit_number_literal(&mut self, lit: &'a NumberLiteral<'a>) {
         let kind = AstKind::NumberLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_boolean_literal(&mut self, lit: &'a BooleanLiteral) {
         let kind = AstKind::BooleanLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_null_literal(&mut self, lit: &'a NullLiteral) {
         let kind = AstKind::NullLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_bigint_literal(&mut self, lit: &'a BigintLiteral) {
         let kind = AstKind::BigintLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_string_literal(&mut self, lit: &'a StringLiteral) {
         let kind = AstKind::StringLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_template_literal(&mut self, lit: &'a TemplateLiteral<'a>) {
         let kind = AstKind::TemplateLiteral(lit);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for elem in &lit.quasis {
             self.visit_template_element(elem);
         }
         for expr in &lit.expressions {
             self.visit_expression(expr);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_reg_expr_literal(&mut self, lit: &'a RegExpLiteral) {
         let kind = AstKind::RegExpLiteral(lit);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_template_element(&mut self, _elem: &'a TemplateElement) {}
@@ -1129,7 +1129,7 @@ pub trait Visit<'a>: Sized {
 
     fn visit_module_declaration(&mut self, decl: &'a ModuleDeclaration<'a>) {
         let kind = AstKind::ModuleDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match &decl.kind {
             ModuleDeclarationKind::ImportDeclaration(decl) => {
                 self.visit_import_declaration(decl);
@@ -1148,7 +1148,7 @@ pub trait Visit<'a>: Sized {
             }
             ModuleDeclarationKind::TSNamespaceExportDeclaration(_) => {}
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_import_declaration(&mut self, decl: &'a ImportDeclaration<'a>) {
@@ -1207,23 +1207,23 @@ pub trait Visit<'a>: Sized {
 
     fn visit_enum_member(&mut self, member: &'a TSEnumMember<'a>) {
         let kind = AstKind::TSEnumMember(member);
-        self.enter_span(kind);
+        self.enter_node(kind);
 
         if let Some(initializer) = &member.initializer {
             self.visit_expression(initializer);
         }
 
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_enum(&mut self, decl: &'a TSEnumDeclaration<'a>) {
         let kind = AstKind::TSEnumDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_binding_identifier(&decl.id);
         for member in &decl.members {
             self.visit_enum_member(member);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_declaration(&mut self, decl: &'a Declaration<'a>) {
@@ -1249,14 +1249,14 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_import_equals_declaration(&mut self, decl: &'a TSImportEqualsDeclaration<'a>) {
         let kind = AstKind::TSImportEqualsDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_binding_identifier(&decl.id);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_module_declaration(&mut self, decl: &'a TSModuleDeclaration<'a>) {
         let kind = AstKind::TSModuleDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match &decl.id {
             TSModuleDeclarationName::Identifier(ident) => self.visit_identifier_name(ident),
             TSModuleDeclarationName::StringLiteral(lit) => self.visit_string_literal(lit),
@@ -1267,30 +1267,30 @@ pub trait Visit<'a>: Sized {
             }
             TSModuleDeclarationBody::TSModuleBlock(block) => self.visit_ts_module_block(block),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_module_block(&mut self, block: &'a TSModuleBlock<'a>) {
         let kind = AstKind::TSModuleBlock(block);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_statements(&block.body);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_alias_declaration(&mut self, decl: &'a TSTypeAliasDeclaration<'a>) {
         let kind = AstKind::TSTypeAliasDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_binding_identifier(&decl.id);
         if let Some(parameters) = &decl.type_parameters {
             self.visit_ts_type_parameter_declaration(parameters);
         }
         self.visit_ts_type(&decl.type_annotation);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_interface_declaration(&mut self, decl: &'a TSInterfaceDeclaration<'a>) {
         let kind = AstKind::TSInterfaceDeclaration(decl);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_binding_identifier(&decl.id);
         if let Some(parameters) = &decl.type_parameters {
             self.visit_ts_type_parameter_declaration(parameters);
@@ -1298,30 +1298,30 @@ pub trait Visit<'a>: Sized {
         for signature in &decl.body.body {
             self.visit_ts_signature(signature);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_as_expression(&mut self, expr: &'a TSAsExpression<'a>) {
         let kind = AstKind::TSAsExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.expression);
         self.visit_ts_type(&expr.type_annotation);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_non_null_expression(&mut self, expr: &'a TSNonNullExpression<'a>) {
         let kind = AstKind::TSNonNullExpression(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.expression);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_assertion(&mut self, expr: &'a TSTypeAssertion<'a>) {
         let kind = AstKind::TSTypeAssertion(expr);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_expression(&expr.expression);
         self.visit_ts_type(&expr.type_annotation);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_instantiation_expression(&mut self, expr: &'a TSInstantiationExpression<'a>) {
@@ -1331,9 +1331,9 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_type_annotation(&mut self, annotation: &'a TSTypeAnnotation<'a>) {
         let kind = AstKind::TSTypeAnnotation(annotation);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_ts_type(&annotation.type_annotation);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type(&mut self, ty: &'a TSType<'a>) {
@@ -1361,19 +1361,19 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_type_literal(&mut self, ty: &'a TSTypeLiteral<'a>) {
         let kind = AstKind::TSTypeLiteral(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for signature in &ty.members {
             self.visit_ts_signature(signature);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_indexed_access_type(&mut self, ty: &'a TSIndexedAccessType<'a>) {
         let kind = AstKind::TSIndexedAccessType(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_ts_type(&ty.object_type);
         self.visit_ts_type(&ty.index_type);
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_predicate(&mut self, ty: &'a TSTypePredicate<'a>) {
@@ -1419,7 +1419,7 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_type_parameter(&mut self, ty: &'a TSTypeParameter<'a>) {
         let kind = AstKind::TSTypeParameter(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         if let Some(constraint) = &ty.constraint {
             self.visit_ts_type(constraint);
         }
@@ -1427,25 +1427,25 @@ pub trait Visit<'a>: Sized {
         if let Some(default) = &ty.default {
             self.visit_ts_type(default);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_parameter_instantiation(&mut self, ty: &'a TSTypeParameterInstantiation<'a>) {
         let kind = AstKind::TSTypeParameterInstantiation(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for ts_parameter in &ty.params {
             self.visit_ts_type(ts_parameter);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_parameter_declaration(&mut self, ty: &'a TSTypeParameterDeclaration<'a>) {
         let kind = AstKind::TSTypeParameterDeclaration(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for ts_parameter in &ty.params {
             self.visit_ts_type_parameter(ts_parameter);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_constructor_type(&mut self, ty: &'a TSConstructorType<'a>) {
@@ -1476,53 +1476,53 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_null_keyword(&mut self, ty: &'a TSNullKeyword) {
         let kind = AstKind::TSNullKeyword(ty);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_any_keyword(&mut self, ty: &'a TSAnyKeyword) {
         let kind = AstKind::TSAnyKeyword(ty);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_void_keyword(&mut self, ty: &'a TSVoidKeyword) {
         let kind = AstKind::TSVoidKeyword(ty);
-        self.enter_span(kind);
-        self.leave_span(kind);
+        self.enter_node(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_intersection_type(&mut self, ty: &'a TSIntersectionType<'a>) {
         let kind = AstKind::TSIntersectionType(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for ty in &ty.types {
             self.visit_ts_type(ty);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_type_reference(&mut self, ty: &'a TSTypeReference<'a>) {
         let kind = AstKind::TSTypeReference(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_ts_type_name(&ty.type_name);
         if let Some(parameters) = &ty.type_parameters {
             self.visit_ts_type_parameter_instantiation(parameters);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_union_type(&mut self, ty: &'a TSUnionType<'a>) {
         let kind = AstKind::TSUnionType(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         for ty in &ty.types {
             self.visit_ts_type(ty);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_literal_type(&mut self, ty: &'a TSLiteralType<'a>) {
         let kind = AstKind::TSLiteralType(ty);
-        self.enter_span(kind);
+        self.enter_node(kind);
         match &ty.literal {
             TSLiteral::BigintLiteral(lit) => self.visit_bigint_literal(lit),
             TSLiteral::BooleanLiteral(lit) => self.visit_boolean_literal(lit),
@@ -1533,7 +1533,7 @@ pub trait Visit<'a>: Sized {
             TSLiteral::TemplateLiteral(lit) => self.visit_template_literal(lit),
             TSLiteral::UnaryExpression(expr) => self.visit_unary_expression(expr),
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     #[allow(clippy::single_match)]
@@ -1566,7 +1566,7 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_method_signature(&mut self, signature: &'a TSMethodSignature<'a>) {
         let kind = AstKind::TSMethodSignature(signature);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_formal_parameters(&signature.params);
         if let Some(parameters) = &signature.type_parameters {
             self.visit_ts_type_parameter_declaration(parameters);
@@ -1574,7 +1574,7 @@ pub trait Visit<'a>: Sized {
         if let Some(annotation) = &signature.return_type {
             self.visit_ts_type_annotation(annotation);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_index_signature_name(&mut self, name: &'a TSIndexSignatureName<'a>) {
@@ -1591,12 +1591,12 @@ pub trait Visit<'a>: Sized {
 
     fn visit_ts_property_signature(&mut self, signature: &'a TSPropertySignature<'a>) {
         let kind = AstKind::TSPropertySignature(signature);
-        self.enter_span(kind);
+        self.enter_node(kind);
         self.visit_property_key(&signature.key);
         if let Some(annotation) = &signature.type_annotation {
             self.visit_ts_type_annotation(annotation);
         }
-        self.leave_span(kind);
+        self.leave_node(kind);
     }
 
     fn visit_ts_call_signature_declaration(