refactor(oxlint-plugin): consolidate five copies of isFunctionLike

Five sites each defined isFunctionLike — the test for whether an AST
node is one of the three function shapes (ArrowFunctionExpression,
FunctionExpression, FunctionDeclaration):

- rules/react-builtins/rules-of-hooks.ts (plain boolean, used local
  FUNCTION_LIKE_TYPES)
- semantic/closure-captures.ts (plain boolean)
- semantic/control-flow-graph.ts (plain boolean)
- semantic/scope-analysis.ts (plain boolean)
- rules/state-and-effects/utils/effect/react.ts (type-guard form
  with null/undefined handling — strictly more useful)

Promote the type-guard form from effect/react.ts to
utils/is-function-like.ts and have all five sites import from it.
The five callsites all pass a non-null EsTreeNode, so the narrowed
signature (EsTreeNode | null | undefined → type guard) is a strict
generalisation. The four sites that previously kept their own
FUNCTION_LIKE_TYPES import no longer need it (the predicate's
internals use isNodeOfType directly).

Behaviour-neutral; -22 lines net.

Co-authored-by: Aiden Bai <aidenybai@users.noreply.github.com>

Author: cursoragent

packages/oxlint-plugin-react-doctor/src/plugin/rules/react-builtins/rules-of-hooks.ts

@@ -5,8 +5,8 @@ import type { EsTreeNodeOfType } from "../../utils/es-tree-node-of-type.js";
 import { isNodeOfType } from "../../utils/is-node-of-type.js";
 import { isReactComponentOrHookName } from "../../utils/is-react-component-or-hook-name.js";
 import { isReactHookName } from "../../utils/is-react-hook-name.js";
-import { FUNCTION_LIKE_TYPES } from "../../constants/js.js";
 import { REACT_HOC_NAMES } from "../../constants/react.js";
+import { isFunctionLike } from "../../utils/is-function-like.js";
 import type { Rule } from "../../utils/rule.js";
 
 // Port of `oxc_linter::rules::react::rules_of_hooks`. Enforces React's
@@ -330,8 +330,6 @@ const inferDestructureSourceKey = (bindingIdentifier: EsTreeNode): string | null
 // component / custom hook scope.
 const isReactUseHook = (hookName: string): boolean => hookName === "use";
 
-const isFunctionLike = (node: EsTreeNode): boolean => FUNCTION_LIKE_TYPES.has(node.type);
-
 interface FunctionInfo {
   node: EsTreeNode;
   // The name we'd display in error messages. Best-effort: the

packages/oxlint-plugin-react-doctor/src/plugin/rules/state-and-effects/utils/effect/react.ts

@@ -2,6 +2,7 @@ import type { Reference, Scope } from "eslint-scope";
 import type { EsTreeNode } from "../../../../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../../../../utils/es-tree-node-of-type.js";
 import { isAstNode } from "../../../../utils/is-ast-node.js";
+import { isFunctionLike } from "../../../../utils/is-function-like.js";
 import { isNodeOfType } from "../../../../utils/is-node-of-type.js";
 import { getDownstreamRefs, getRef, getUpstreamRefs, isEventualCallTo } from "./ast.js";
 import type { ProgramAnalysis } from "./get-program-analysis.js";
@@ -40,19 +41,6 @@ const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name: string | undefined): boolean =>
   Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
 
-const isFunctionLike = (
-  node: EsTreeNode | null | undefined,
-): node is
-  | EsTreeNodeOfType<"ArrowFunctionExpression">
-  | EsTreeNodeOfType<"FunctionExpression">
-  | EsTreeNodeOfType<"FunctionDeclaration"> =>
-  Boolean(
-    node &&
-    (isNodeOfType(node, "ArrowFunctionExpression") ||
-      isNodeOfType(node, "FunctionExpression") ||
-      isNodeOfType(node, "FunctionDeclaration")),
-  );
-
 const isReactFunctionalComponent = (node: EsTreeNode | null | undefined): boolean => {
   if (!node) return false;
   if (isNodeOfType(node, "FunctionDeclaration")) {

packages/oxlint-plugin-react-doctor/src/plugin/semantic/closure-captures.ts

@@ -1,10 +1,8 @@
-import { FUNCTION_LIKE_TYPES } from "../constants/js.js";
 import type { EsTreeNode } from "../utils/es-tree-node.js";
 import type { ReferenceDescriptor, ScopeAnalysis } from "./scope-analysis.js";
 import { isDescendantScope } from "./scope-analysis.js";
 import { isAstNode } from "../utils/is-ast-node.js";
-
-const isFunctionLike = (node: EsTreeNode): boolean => FUNCTION_LIKE_TYPES.has(node.type);
+import { isFunctionLike } from "../utils/is-function-like.js";
 
 const TYPE_ONLY_CHILD_KEYS: ReadonlySet<string> = new Set([
   "implements",

packages/oxlint-plugin-react-doctor/src/plugin/semantic/control-flow-graph.ts

@@ -1,6 +1,6 @@
-import { FUNCTION_LIKE_TYPES } from "../constants/js.js";
 import type { EsTreeNode } from "../utils/es-tree-node.js";
 import { isAstNode } from "../utils/is-ast-node.js";
+import { isFunctionLike } from "../utils/is-function-like.js";
 import { isNodeOfType } from "../utils/is-node-of-type.js";
 
 // Per-function CFG. Mirrors the subset of `oxc_cfg` we need to answer:
@@ -48,8 +48,6 @@ export interface ControlFlowAnalysis {
 }
 
 
-const isFunctionLike = (node: EsTreeNode): boolean => FUNCTION_LIKE_TYPES.has(node.type);
-
 interface CfgBuilder {
   blocks: BasicBlock[];
   entry: BasicBlock;

packages/oxlint-plugin-react-doctor/src/plugin/semantic/scope-analysis.ts

@@ -1,7 +1,7 @@
-import { FUNCTION_LIKE_TYPES } from "../constants/js.js";
 import type { EsTreeNode } from "../utils/es-tree-node.js";
 import type { EsTreeNodeOfType } from "../utils/es-tree-node-of-type.js";
 import { isAstNode } from "../utils/is-ast-node.js";
+import { isFunctionLike } from "../utils/is-function-like.js";
 import { isNodeOfType } from "../utils/is-node-of-type.js";
 
 // Scope analyzer — per-file walker building a scope tree, symbol
@@ -100,8 +100,6 @@ export interface ScopeAnalysis {
   readonly isGlobalReference: (identifier: EsTreeNode) => boolean;
 }
 
-const isFunctionLike = (node: EsTreeNode): boolean => FUNCTION_LIKE_TYPES.has(node.type);
-
 const isHoistedBindingKind = (kind: SymbolKind): boolean => kind === "var" || kind === "function";
 
 // Returns the nearest enclosing function-or-program scope for hoisting

packages/oxlint-plugin-react-doctor/src/plugin/utils/is-function-like.ts

@@ -0,0 +1,26 @@
+import type { EsTreeNode } from "./es-tree-node.js";
+import type { EsTreeNodeOfType } from "./es-tree-node-of-type.js";
+import { isNodeOfType } from "./is-node-of-type.js";
+
+/**
+ * Type-guard for the three "function-like" ESTree node shapes:
+ * `ArrowFunctionExpression`, `FunctionExpression`,
+ * `FunctionDeclaration`. Accepts `null | undefined` so callers
+ * walking parent chains don't need their own pre-check.
+ *
+ * Was duplicated across five sites as both a plain boolean check
+ * (`FUNCTION_LIKE_TYPES.has(node.type)`) and as a type-guard. The
+ * type-guard form covers both shapes without callers paying a cast.
+ */
+export const isFunctionLike = (
+  node: EsTreeNode | null | undefined,
+): node is
+  | EsTreeNodeOfType<"ArrowFunctionExpression">
+  | EsTreeNodeOfType<"FunctionExpression">
+  | EsTreeNodeOfType<"FunctionDeclaration"> =>
+  Boolean(
+    node &&
+      (isNodeOfType(node, "ArrowFunctionExpression") ||
+        isNodeOfType(node, "FunctionExpression") ||
+        isNodeOfType(node, "FunctionDeclaration")),
+  );