refactor(semantic)!: rename AstNode to Node and AstNodes to Nodes

Author: overlookmotel

crates/oxc_linter/src/ast_util.rs

@@ -1,5 +1,5 @@
 use oxc_ast::{ast::BindingIdentifier, AstKind};
-use oxc_semantic::{AstNode, IsGlobalReference, NodeId, SymbolId};
+use oxc_semantic::{IsGlobalReference, Node, NodeId, SymbolId};
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator};
 
@@ -181,9 +181,9 @@ impl<'a, 'b> IsConstant<'a, 'b> for SpreadElement<'a> {
 /// Return the innermost `Function` or `ArrowFunctionExpression` Node
 /// enclosing the specified node
 pub fn get_enclosing_function<'a, 'b>(
-    node: &'b AstNode<'a>,
+    node: &'b Node<'a>,
     ctx: &'b LintContext<'a>,
-) -> Option<&'b AstNode<'a>> {
+) -> Option<&'b Node<'a>> {
     let mut current_node = node;
     loop {
         if matches!(current_node.kind(), AstKind::Program(_)) {
@@ -204,7 +204,7 @@ pub fn is_nth_argument<'a>(call: &CallExpression<'a>, arg: &Argument<'a>, n: usi
 }
 
 /// Jump to the outer most of chained parentheses if any
-pub fn outermost_paren<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>) -> &'b AstNode<'a> {
+pub fn outermost_paren<'a, 'b>(node: &'b Node<'a>, ctx: &'b LintContext<'a>) -> &'b Node<'a> {
     let mut node = node;
 
     loop {
@@ -222,20 +222,20 @@ pub fn outermost_paren<'a, 'b>(node: &'b AstNode<'a>, ctx: &'b LintContext<'a>)
 }
 
 pub fn outermost_paren_parent<'a, 'b>(
-    node: &'b AstNode<'a>,
+    node: &'b Node<'a>,
     ctx: &'b LintContext<'a>,
-) -> Option<&'b AstNode<'a>> {
+) -> Option<&'b Node<'a>> {
     ctx.nodes()
         .iter_parents(node.id())
         .skip(1)
         .find(|parent| !matches!(parent.kind(), AstKind::ParenthesizedExpression(_)))
 }
 
 pub fn nth_outermost_paren_parent<'a, 'b>(
-    node: &'b AstNode<'a>,
+    node: &'b Node<'a>,
     ctx: &'b LintContext<'a>,
     n: usize,
-) -> Option<&'b AstNode<'a>> {
+) -> Option<&'b Node<'a>> {
     ctx.nodes()
         .iter_parents(node.id())
         .skip(1)
@@ -247,7 +247,7 @@ pub fn nth_outermost_paren_parent<'a, 'b>(
 pub fn iter_outer_expressions<'a, 'ctx>(
     ctx: &'ctx LintContext<'a>,
     node_id: NodeId,
-) -> impl Iterator<Item = &'ctx AstNode<'a>> + 'ctx {
+) -> impl Iterator<Item = &'ctx Node<'a>> + 'ctx {
     ctx.nodes().iter_parents(node_id).skip(1).filter(|parent| {
         !matches!(
             parent.kind(),
@@ -264,7 +264,7 @@ pub fn iter_outer_expressions<'a, 'ctx>(
 pub fn get_declaration_of_variable<'a, 'b>(
     ident: &IdentifierReference,
     ctx: &'b LintContext<'a>,
-) -> Option<&'b AstNode<'a>> {
+) -> Option<&'b Node<'a>> {
     let symbol_id = get_symbol_id_of_variable(ident, ctx)?;
     let symbol_table = ctx.semantic().symbols();
     Some(ctx.nodes().get_node(symbol_table.get_declaration(symbol_id)))
@@ -391,7 +391,7 @@ pub fn is_global_require_call(call_expr: &CallExpression, ctx: &LintContext) ->
     call_expr.callee.is_global_reference_name("require", ctx.symbols())
 }
 
-pub fn is_function_node(node: &AstNode) -> bool {
+pub fn is_function_node(node: &Node) -> bool {
     match node.kind() {
         AstKind::Function(f) if f.is_function_declaration() => true,
         AstKind::Function(f) if f.is_expression() => true,
@@ -401,7 +401,7 @@ pub fn is_function_node(node: &AstNode) -> bool {
 }
 
 pub fn get_function_like_declaration<'b>(
-    node: &AstNode<'b>,
+    node: &Node<'b>,
     ctx: &LintContext<'b>,
 ) -> Option<&'b BindingIdentifier<'b>> {
     let parent = outermost_paren_parent(node, ctx)?;

crates/oxc_linter/src/context.rs

@@ -3,7 +3,7 @@ use std::{cell::RefCell, path::Path, rc::Rc, sync::Arc};
 
 use oxc_cfg::ControlFlowGraph;
 use oxc_diagnostics::{OxcDiagnostic, Severity};
-use oxc_semantic::{AstNodes, JSDocFinder, ScopeTree, Semantic, SymbolTable};
+use oxc_semantic::{JSDocFinder, Nodes, ScopeTree, Semantic, SymbolTable};
 use oxc_span::{GetSpan, SourceType, Span};
 use oxc_syntax::module_record::ModuleRecord;
 
@@ -349,7 +349,7 @@ impl<'a> LintContext<'a> {
     /// AST nodes
     ///
     /// Shorthand for `self.semantic().nodes()`.
-    pub fn nodes(&self) -> &AstNodes<'a> {
+    pub fn nodes(&self) -> &Nodes<'a> {
         self.semantic().nodes()
     }
 

crates/oxc_linter/src/lib.rs

@@ -25,7 +25,7 @@ use std::{io::Write, path::Path, rc::Rc, sync::Arc};
 use config::LintConfig;
 use options::LintOptions;
 use oxc_diagnostics::Error;
-use oxc_semantic::{AstNode, Semantic};
+use oxc_semantic::{Node, Semantic};
 
 pub use crate::{
     config::OxlintConfig,

crates/oxc_linter/src/rule.rs

@@ -7,7 +7,7 @@ use std::{
 
 use oxc_semantic::SymbolId;
 
-use crate::{context::LintContext, AllowWarnDeny, AstNode, FixKind, RuleEnum};
+use crate::{context::LintContext, AllowWarnDeny, FixKind, Node, RuleEnum};
 
 pub trait Rule: Sized + Default + fmt::Debug {
     /// Initialize from eslint json configuration
@@ -18,7 +18,7 @@ pub trait Rule: Sized + Default + fmt::Debug {
     /// Visit each AST Node
     #[expect(unused_variables)]
     #[inline]
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {}
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {}
 
     /// Visit each symbol
     #[expect(unused_variables)]

crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs

@@ -14,7 +14,7 @@ use crate::{
     ast_util::{get_enclosing_function, is_nth_argument, outermost_paren},
     context::LintContext,
     rule::Rule,
-    AstNode,
+    Node,
 };
 
 fn expect_return(method_name: &str, span: Span) -> OxcDiagnostic {
@@ -76,7 +76,7 @@ impl Rule for ArrayCallbackReturn {
         Self { check_for_each, allow_implicit_return }
     }
 
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         let (function_body, always_explicit_return) = match node.kind() {
             // Async, generator, and single expression arrow functions
             // always have explicit return value
@@ -135,10 +135,7 @@ impl Rule for ArrayCallbackReturn {
 /// Code ported from [eslint](https://github.com/eslint/eslint/blob/main/lib/rules/array-callback-return.js)
 /// We're currently on a `Function` or `ArrowFunctionExpression`, findout if it is an argument
 /// to the target array methods we're interested in.
-pub fn get_array_method_name<'a>(
-    node: &AstNode<'a>,
-    ctx: &LintContext<'a>,
-) -> Option<&'static str> {
+pub fn get_array_method_name<'a>(node: &Node<'a>, ctx: &LintContext<'a>) -> Option<&'static str> {
     let mut current_node = node;
     while let Some(parent) = ctx.nodes().parent_node(current_node.id()) {
         match parent.kind() {

crates/oxc_linter/src/rules/eslint/constructor_super.rs

@@ -1,7 +1,7 @@
 use oxc_macros::declare_oxc_lint;
 
 // use oxc_span::Span;
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 // #[derive(Debug, Error, Diagnostic)]
 // #[error("Expected to call 'super()'.")]
@@ -38,7 +38,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for ConstructorSuper {
-    fn run<'a>(&self, _node: &AstNode<'a>, _ctx: &LintContext<'a>) {}
+    fn run<'a>(&self, _node: &Node<'a>, _ctx: &LintContext<'a>) {}
 }
 
 #[test]

crates/oxc_linter/src/rules/eslint/default_case.rs

@@ -4,7 +4,7 @@ use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use regex::{Regex, RegexBuilder};
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn default_case_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Require default cases in switch statements.")
@@ -62,7 +62,7 @@ impl Rule for DefaultCase {
         Self(Box::new(cfg))
     }
 
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         if let AstKind::SwitchStatement(switch) = node.kind() {
             let cases = &switch.cases;
 

crates/oxc_linter/src/rules/eslint/default_case_last.rs

@@ -3,7 +3,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn default_case_last_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Enforce default clauses in switch statements to be last")
@@ -51,7 +51,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for DefaultCaseLast {
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         let AstKind::SwitchStatement(switch) = node.kind() else {
             return;
         };

crates/oxc_linter/src/rules/eslint/default_param_last.rs

@@ -3,7 +3,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn default_param_last_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Default parameters should be last")
@@ -36,7 +36,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for DefaultParamLast {
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::Function(function) => {
                 if !function.is_declaration() && !function.is_expression() {

crates/oxc_linter/src/rules/eslint/eqeqeq.rs

@@ -7,7 +7,7 @@ use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{BinaryOperator, UnaryOperator};
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn eqeqeq_diagnostic(x0: &str, x1: &str, span2: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn(format!("Expected {x1} and instead saw {x0}"))
@@ -57,7 +57,7 @@ impl Rule for Eqeqeq {
         }
     }
 
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         let AstKind::BinaryExpression(binary_expr) = node.kind() else {
             return;
         };

crates/oxc_linter/src/rules/eslint/for_direction.rs

@@ -10,7 +10,7 @@ use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator, UpdateOperator};
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn for_direction_diagnostic(span: Span, span1: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("The update clause in this loop moves the variable in the wrong direction")
@@ -82,7 +82,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for ForDirection {
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         let AstKind::ForStatement(for_loop) = node.kind() else {
             return;
         };

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

@@ -14,7 +14,7 @@ use oxc_span::{Atom, GetSpan, Span};
 use oxc_syntax::identifier::is_identifier_name;
 use phf::phf_set;
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn named_diagnostic(function_name: &str, span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn(format!("Unexpected named {function_name}."))
@@ -43,7 +43,7 @@ enum FuncNamesConfig {
 }
 
 impl FuncNamesConfig {
-    fn is_invalid_function(self, func: &Function, parent_node: &AstNode<'_>) -> bool {
+    fn is_invalid_function(self, func: &Function, parent_node: &Node<'_>) -> bool {
         let func_name = func.name();
 
         match self {
@@ -147,7 +147,7 @@ declare_oxc_lint!(
 
 /// Determines whether the current FunctionExpression node is a get, set, or
 /// shorthand method in an object literal or a class.
-fn is_object_or_class_method(parent_node: &AstNode) -> bool {
+fn is_object_or_class_method(parent_node: &Node) -> bool {
     match parent_node.kind() {
         AstKind::MethodDefinition(_) => true,
         AstKind::ObjectProperty(property) => {
@@ -161,7 +161,7 @@ fn is_object_or_class_method(parent_node: &AstNode) -> bool {
 
 /// Determines whether the current FunctionExpression node has a name that would be
 /// inferred from context in a conforming ES6 environment.
-fn has_inferred_name<'a>(function: &Function<'a>, parent_node: &AstNode<'a>) -> bool {
+fn has_inferred_name<'a>(function: &Function<'a>, parent_node: &Node<'a>) -> bool {
     if is_object_or_class_method(parent_node) {
         return true;
     }
@@ -255,7 +255,7 @@ fn get_property_key_name<'a>(key: &PropertyKey<'a>) -> Option<Cow<'a, str>> {
     }
 }
 
-fn get_static_property_name<'a>(parent_node: &AstNode<'a>) -> Option<Cow<'a, str>> {
+fn get_static_property_name<'a>(parent_node: &Node<'a>) -> Option<Cow<'a, str>> {
     let (key, computed) = match parent_node.kind() {
         AstKind::PropertyDefinition(definition) => (&definition.key, definition.computed),
         AstKind::MethodDefinition(method_definition) => {
@@ -274,7 +274,7 @@ fn get_static_property_name<'a>(parent_node: &AstNode<'a>) -> Option<Cow<'a, str
 
 /// Gets the name and kind of the given function node.
 /// @see <https://github.com/eslint/eslint/blob/48117b27e98639ffe7e78a230bfad9a93039fb7f/lib/rules/utils/ast-utils.js#L1762>
-fn get_function_name_with_kind<'a>(func: &Function<'a>, parent_node: &AstNode<'a>) -> Cow<'a, str> {
+fn get_function_name_with_kind<'a>(func: &Function<'a>, parent_node: &Node<'a>) -> Cow<'a, str> {
     let mut tokens: Vec<Cow<'a, str>> = vec![];
 
     match parent_node.kind() {
@@ -370,7 +370,7 @@ impl Rule for FuncNames {
     }
 
     fn run_once(&self, ctx: &LintContext<'_>) {
-        let mut invalid_funcs: Vec<(&Function, &AstNode)> = vec![];
+        let mut invalid_funcs: Vec<(&Function, &Node)> = vec![];
 
         for node in ctx.nodes().iter() {
             match node.kind() {
@@ -480,7 +480,7 @@ impl Rule for FuncNames {
 }
 
 fn guess_function_name<'a>(ctx: &LintContext<'a>, parent_id: NodeId) -> Option<Cow<'a, str>> {
-    for parent_kind in ctx.nodes().iter_parents(parent_id).map(AstNode::kind) {
+    for parent_kind in ctx.nodes().iter_parents(parent_id).map(Node::kind) {
         match parent_kind {
             AstKind::ParenthesizedExpression(_)
             | AstKind::TSAsExpression(_)

crates/oxc_linter/src/rules/eslint/getter_return.rs

@@ -16,7 +16,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn getter_return_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Expected to always return a value in getter.")
@@ -56,7 +56,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for GetterReturn {
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         // https://eslint.org/docs/latest/rules/getter-return#handled_by_typescript
         if ctx.source_type().is_typescript() {
             return;
@@ -119,7 +119,7 @@ impl GetterReturn {
     }
 
     /// Checks whether it is necessary to check the node
-    fn is_wanted_node(node: &AstNode, ctx: &LintContext<'_>) -> Option<bool> {
+    fn is_wanted_node(node: &Node, ctx: &LintContext<'_>) -> Option<bool> {
         let parent = ctx.nodes().parent_node(node.id())?;
         match parent.kind() {
             AstKind::MethodDefinition(mdef) => {
@@ -177,7 +177,7 @@ impl GetterReturn {
         Some(false)
     }
 
-    fn run_diagnostic<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>, span: Span) {
+    fn run_diagnostic<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>, span: Span) {
         if !Self::is_wanted_node(node, ctx).unwrap_or_default() {
             return;
         }

crates/oxc_linter/src/rules/eslint/guard_for_in.rs

@@ -3,7 +3,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 
-use crate::{context::LintContext, rule::Rule, AstNode};
+use crate::{context::LintContext, rule::Rule, Node};
 
 fn guard_for_in_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Require `for-in` loops to include an `if` statement")
@@ -32,7 +32,7 @@ declare_oxc_lint!(
 );
 
 impl Rule for GuardForIn {
-    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
+    fn run<'a>(&self, node: &Node<'a>, ctx: &LintContext<'a>) {
         if let AstKind::ForInStatement(for_in_statement) = node.kind() {
             match &for_in_statement.body {
                 Statement::EmptyStatement(_) | Statement::IfStatement(_) => return,