perf(semantic,linter): simplify implementation and uses of ancestors iterators (#12164)

This simplifies the implementation and uses of `ancestor_ids`,
`ancestor_kinds` and `ancestors` iterators by changing its first
returned item from the provided node to the first parent of this node.
This makes the implementation of those iterators simpler and makes code
in most lint rules shorter by mainly removing the often called
`.skip(1)`.

All tests are green, but as always I probably broke something untested
because of the scale and impact of this change. I'm not quite happy with
me having to resort to `iter::once` twice in `no_unused_vars` lint rule,
but I couldn't come up with a better solution. But having much less
code, simpler implementation of the iterators and hopefully a
performance gain in the linter benchmarks is definitely worth the
change.

Continuation of #12123 and #12087
Closes #12151

Author: ulrichstark

crates/oxc_linter/src/ast_util.rs

@@ -241,7 +241,6 @@ pub fn outermost_paren_parent<'a, 'b>(
     semantic
         .nodes()
         .ancestors(node.id())
-        .skip(1)
         .find(|parent| !matches!(parent.kind(), AstKind::ParenthesizedExpression(_)))
 }
 
@@ -253,7 +252,6 @@ pub fn nth_outermost_paren_parent<'a, 'b>(
     semantic
         .nodes()
         .ancestors(node.id())
-        .skip(1)
         .filter(|parent| !matches!(parent.kind(), AstKind::ParenthesizedExpression(_)))
         .nth(n)
 }
@@ -264,7 +262,7 @@ pub fn iter_outer_expressions<'a, 's>(
     semantic: &'s Semantic<'a>,
     node_id: NodeId,
 ) -> impl Iterator<Item = AstKind<'a>> + 's {
-    semantic.nodes().ancestor_kinds(node_id).skip(1).filter(|parent| {
+    semantic.nodes().ancestor_kinds(node_id).filter(|parent| {
         !matches!(
             parent,
             AstKind::ParenthesizedExpression(_)
@@ -661,7 +659,7 @@ pub fn is_default_this_binding<'a>(
                 current_node = parent;
             }
             AstKind::ReturnStatement(_) => {
-                let upper_func = semantic.nodes().ancestors(parent.id()).skip(1).find(|node| {
+                let upper_func = semantic.nodes().ancestors(parent.id()).find(|node| {
                     matches!(
                         node.kind(),
                         AstKind::Function(_) | AstKind::ArrowFunctionExpression(_)

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

@@ -272,7 +272,7 @@ impl Rule for FuncNames {
 
                         // a function which is calling itself inside is always valid
                         let ast_span =
-                            ctx.nodes().ancestors(node.id()).skip(1).find_map(|p| match p.kind() {
+                            ctx.nodes().ancestors(node.id()).find_map(|p| match p.kind() {
                                 AstKind::Function(func) => {
                                     let func_name = func.name()?;
 
@@ -314,7 +314,7 @@ impl Rule for FuncNames {
                 ctx.diagnostic_with_fix(
                     unnamed_diagnostic(&func_name_complete, report_span),
                     |fixer| {
-                        guess_function_name(ctx, parent_node.id()).map_or_else(
+                        guess_function_name(ctx, node.id()).map_or_else(
                             || fixer.noop(),
                             |name| {
                                 // if this name shadows a variable in the outer scope **and** that name is referenced
@@ -346,8 +346,8 @@ 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().ancestor_kinds(parent_id) {
+fn guess_function_name<'a>(ctx: &LintContext<'a>, node_id: NodeId) -> Option<Cow<'a, str>> {
+    for parent_kind in ctx.nodes().ancestor_kinds(node_id) {
         match parent_kind {
             AstKind::ParenthesizedExpression(_)
             | AstKind::TSAsExpression(_)

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

@@ -297,7 +297,6 @@ impl Rule for FuncStyle {
                     let arrow_func_ancestor = semantic
                         .nodes()
                         .ancestors(node.id())
-                        .skip(1)
                         .find(|v| matches!(v.kind(), AstKind::FunctionBody(_)))
                         .map(|el| semantic.nodes().parent_node(el.id()));
                     if let Some(ret) = arrow_func_ancestor {

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

@@ -135,7 +135,7 @@ impl Rule for InitDeclarations {
                     return;
                 }
                 let decl_ancestor =
-                    ctx.nodes().ancestor_kinds(node.id()).skip(1).find(|el| {
+                    ctx.nodes().ancestor_kinds(node.id()).find(|el| {
                         matches!(el, AstKind::TSModuleDeclaration(ts_module_decl) if ts_module_decl.declare)
                     });
                 if decl_ancestor.is_some() {

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

@@ -115,7 +115,7 @@ declare_oxc_lint!(
 impl Rule for MaxDepth {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if should_count(node, ctx.nodes()) {
-            let depth = ctx
+            let depth = 1 + ctx
                 .nodes()
                 .ancestors(node.id())
                 .take_while(|node| !should_stop(node))

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

@@ -108,8 +108,8 @@ declare_oxc_lint!(
 
 impl Rule for MaxNestedCallbacks {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
-        if is_function_node(node) {
-            let depth = ctx
+        if is_callback(node, ctx) {
+            let depth = 1 + ctx
                 .semantic()
                 .nodes()
                 .ancestors(node.id())

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

@@ -89,7 +89,7 @@ impl Rule for NoCondAssign {
             }
             AstKind::AssignmentExpression(expr) if self.config == NoCondAssignConfig::Always => {
                 let mut spans = vec![];
-                for ancestor in ctx.nodes().ancestors(node.id()).skip(1) {
+                for ancestor in ctx.nodes().ancestors(node.id()) {
                     match ancestor.kind() {
                         AstKind::IfStatement(if_stmt) => {
                             spans.push(if_stmt.test.span());

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

@@ -158,7 +158,7 @@ fn remove_console<'c, 'a: 'c>(
     node: &AstNode<'a>,
 ) -> RuleFix<'a> {
     let mut node_to_delete = node;
-    for parent in ctx.nodes().ancestors(node.id()).skip(1) {
+    for parent in ctx.nodes().ancestors(node.id()) {
         match parent.kind() {
             AstKind::ParenthesizedExpression(_)
             | AstKind::ExpressionStatement(_)

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

@@ -67,7 +67,7 @@ fn is_constructor(node: &AstNode<'_>) -> bool {
 }
 
 fn is_definitely_in_constructor(ctx: &LintContext, node_id: NodeId) -> bool {
-    for ancestor_id in ctx.nodes().ancestor_ids(node_id).skip(1) {
+    for ancestor_id in ctx.nodes().ancestor_ids(node_id) {
         match ctx.nodes().kind(ancestor_id) {
             AstKind::Function(_) => {
                 return is_constructor(ctx.nodes().parent_node(ancestor_id));

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

@@ -55,7 +55,6 @@ impl Rule for NoDebugger {
                 let Some(parent) = ctx
                     .nodes()
                     .ancestors(node.id())
-                    .skip(1)
                     .find(|p| !matches!(p.kind(), AstKind::ParenthesizedExpression(_)))
                 else {
                     return fixer.delete(&stmt.span).with_message(REMOVE_DEBUGGER);