perf(linter/no-inner-declarations): remove unnecessary code and reduce branches (#11633)

overlookmotel · overlookmotel · commit 2cd786bbc941 · 2025-06-12T11:30:30.000Z
1. Remove unnecessary check that grandparent of node is a `Function` or `ArrowFunctionExpression` when its parent is a `FunctionBody`. `FunctionBody` is always the child of `Function` or `ArrowFunctionExpression`, so this check is redundant.

2. If node is a `VariableStatement` or `Function`, it always has a parent node. So `unwrap` the parent instead of branching `if let Some(parent_node) = parent`. It's always `Some`.

The 2nd also allows skipping 1 turn of the loop further down because:

* If direct parent is a `StaticBlock`, we already exited.
* It's impossible for a variable or function declaration's parent to be a `Function` - there'd have to be a `FunctionBody` in between.
diff --git a/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs b/crates/oxc_linter/src/rules/eslint/no_inner_declarations.rs
@@ -83,33 +83,25 @@ impl Rule for NoInnerDeclarations {
             _ => return,
         };
 
-        let mut parent = ctx.nodes().parent_node(node.id());
-        if let Some(parent_node) = parent {
-            match parent_node.kind() {
-                AstKind::FunctionBody(_) => {
-                    if let Some(grandparent) = ctx.nodes().parent_node(parent_node.id()) {
-                        if grandparent.kind().is_function_like() {
-                            return;
-                        }
-                    }
-                }
-                AstKind::Program(_)
-                | AstKind::StaticBlock(_)
-                | AstKind::ExportNamedDeclaration(_)
-                | AstKind::ExportDefaultDeclaration(_) => return,
-                AstKind::ForStatement(for_stmt) => {
-                    if for_stmt.init.as_ref().is_some_and(|init| init.span() == kind.span()) {
-                        return;
-                    }
-                }
-                AstKind::ForInStatement(for_stmt) if for_stmt.left.span() == kind.span() => {
-                    return;
-                }
-                AstKind::ForOfStatement(for_stmt) if for_stmt.left.span() == kind.span() => {
+        let parent_node = ctx.nodes().parent_node(node.id()).unwrap();
+        match parent_node.kind() {
+            AstKind::Program(_)
+            | AstKind::FunctionBody(_)
+            | AstKind::StaticBlock(_)
+            | AstKind::ExportNamedDeclaration(_)
+            | AstKind::ExportDefaultDeclaration(_) => return,
+            AstKind::ForStatement(for_stmt) => {
+                if for_stmt.init.as_ref().is_some_and(|init| init.span() == kind.span()) {
                     return;
                 }
-                _ => {}
             }
+            AstKind::ForInStatement(for_stmt) if for_stmt.left.span() == kind.span() => {
+                return;
+            }
+            AstKind::ForOfStatement(for_stmt) if for_stmt.left.span() == kind.span() => {
+                return;
+            }
+            _ => {}
         }
 
         let decl_type = match node.kind() {
@@ -119,6 +111,7 @@ impl Rule for NoInnerDeclarations {
         };
 
         let mut body = "program";
+        let mut parent = ctx.nodes().parent_node(parent_node.id());
         while let Some(parent_node) = parent {
             let parent_kind = parent_node.kind();
             match parent_kind {
