fix(prefer-tacit): handling functions that don't map to directly to an eslint node

src/rules/prefer-tacit.ts

@@ -15,20 +15,17 @@ import { ruleNameScope } from "#eslint-plugin-functional/utils/misc";
 import { type ESFunction } from "#eslint-plugin-functional/utils/node-types";
 import {
   createRule,
-  getESTreeNode,
   getTypeOfNode,
+  getTypeOfTSNode,
   type NamedCreateRuleCustomMeta,
   type RuleResult,
 } from "#eslint-plugin-functional/utils/rule";
 import { isNested } from "#eslint-plugin-functional/utils/tree";
 import {
   isBlockStatement,
   isCallExpression,
-  isDefined,
-  isFunctionLike,
   isIdentifier,
   isReturnStatement,
-  isTSFunctionType,
 } from "#eslint-plugin-functional/utils/type-guards";
 
 /**
@@ -106,13 +103,12 @@ function isCallerViolation(
   if (tsDeclaration === undefined) {
     return false;
   }
-  const declaration = getESTreeNode(tsDeclaration, context);
 
-  return (
-    isDefined(declaration) &&
-    (isFunctionLike(declaration) || isTSFunctionType(declaration)) &&
-    declaration.params.length === caller.arguments.length
-  );
+  return getTypeOfTSNode(tsDeclaration, context)
+    .getCallSignatures()
+    .some(
+      (signature) => signature.parameters.length === caller.arguments.length,
+    );
 }
 
 /**

src/utils/rule.ts

@@ -188,12 +188,22 @@ export function getTypeOfNode<Context extends RuleContext<string, BaseOptions>>(
   node: TSESTree.Node,
   context: Context,
 ): Type {
-  const parserServices = getParserServices(context);
+  const { esTreeNodeToTSNodeMap } = getParserServices(context);
 
-  const checker = parserServices.program.getTypeChecker();
-  const { esTreeNodeToTSNodeMap } = parserServices;
+  const tsNode = esTreeNodeToTSNodeMap.get(node);
+  return getTypeOfTSNode(tsNode, context);
+}
+
+/**
+ * Get the type of the the given ts node.
+ */
+export function getTypeOfTSNode<
+  Context extends RuleContext<string, BaseOptions>,
+>(node: TSNode, context: Context): Type {
+  const { program } = getParserServices(context);
+  const checker = program.getTypeChecker();
 
-  const nodeType = checker.getTypeAtLocation(esTreeNodeToTSNodeMap.get(node));
+  const nodeType = checker.getTypeAtLocation(node);
   const constrained = checker.getBaseConstraintOfType(nodeType);
   return constrained ?? nodeType;
 }

tests/rules/prefer-tacit/ts/invalid.ts

@@ -237,6 +237,29 @@ const tests: Array<
       },
     ],
   },
+  // Boolean constructor
+  {
+    code: dedent`
+      const foo = [1, 2, 3].map(x => Boolean(x));
+    `,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "generic",
+        type: AST_NODE_TYPES.ArrowFunctionExpression,
+        line: 1,
+        column: 27,
+        suggestions: [
+          {
+            messageId: "generic",
+            output: dedent`
+            const foo = [1, 2, 3].map(Boolean);
+          `,
+          },
+        ],
+      },
+    ],
+  },
   // Instantiation Expression not supported.
   {
     code: dedent`