feat(functional-parameters): add option to ignore lambda function exp…

…ressions
eslint-functional · Jan 28, 2023 · 044e54b · 044e54b
1 parent c0a8699
commit 044e54b
Show file tree

Hide file tree

Showing 8 changed files with 93 additions and 3 deletions.
diff --git a/docs/rules/functional-parameters.md b/docs/rules/functional-parameters.md
@@ -53,6 +53,7 @@ type Options = {
   allowArgumentsKeyword: boolean;
   enforceParameterCount: "atLeastOne" | "exactlyOne" | false | {
     count: "atLeastOne" | "exactlyOne";
+    ignoreLambdaExpression: boolean,
     ignoreIIFE: boolean;
   };
   ignorePattern?: string[] | string;
@@ -68,13 +69,24 @@ const defaults = {
   allowArgumentsKeyword: false,
   enforceParameterCount: {
     count: "atLeastOne",
+    ignoreLambdaExpression: false,
     ignoreIIFE: true
   }
 }
 ```
 
 ### Preset Overrides
 
+#### `recommended`
+
+```ts
+const recommendedOptions = {
+  enforceParameterCount: {
+    ignoreLambdaExpression: true,
+  },
+}
+```
+
 #### `lite`
 
 ```ts
@@ -133,6 +145,11 @@ See [Currying](https://en.wikipedia.org/wiki/Currying) and [Higher-order functio
 
 See [enforceParameterCount](#enforceparametercount).
 
+### `enforceParameterCount.ignoreLambdaExpression`
+
+If true, this option allows for the use of lambda function expressions that do not have any parameters.
+Here, a lambda function expression refers to any function being defined in place as passed directly as an argument to another function.
+
 #### `enforceParameterCount.ignoreIIFE`
 
 If true, this option allows for the use of [IIFEs](https://developer.mozilla.org/en-US/docs/Glossary/IIFE) that do not have any parameters.

diff --git a/src/configs/recommended.ts b/src/configs/recommended.ts
@@ -2,6 +2,7 @@ import { deepmerge } from "deepmerge-ts";
 import type { Linter } from "eslint";
 import { Immutability } from "is-immutable-type";
 
+import * as functionalParameters from "~/rules/functional-parameters";
 import * as noConditionalStatement from "~/rules/no-conditional-statement";
 import * as noLet from "~/rules/no-let";
 import * as noThrowStatement from "~/rules/no-throw-statement";
@@ -13,6 +14,12 @@ import strict from "./strict";
 
 const overrides: Linter.Config = {
   rules: {
+    [`functional/${functionalParameters.name}`]: [
+      "error",
+      {
+        enforceParameterCount: { ignoreLambdaExpression: true },
+      },
+    ],
     [`functional/${noConditionalStatement.name}`]: [
       "error",
       {

diff --git a/src/rules/functional-parameters.ts b/src/rules/functional-parameters.ts
@@ -15,7 +15,12 @@ import {
 import type { ESFunction } from "~/src/util/node-types";
 import type { RuleResult } from "~/util/rule";
 import { createRuleUsingFunction } from "~/util/rule";
-import { isIIFE, isPropertyAccess, isPropertyName } from "~/util/tree";
+import {
+  isArgument,
+  isIIFE,
+  isPropertyAccess,
+  isPropertyName,
+} from "~/util/tree";
 import { isRestElement } from "~/util/typeguard";
 
 /**
@@ -42,6 +47,7 @@ type Options = readonly [
         | false
         | Readonly<{
             count: ParameterCountOptions;
+            ignoreLambdaExpression: boolean;
             ignoreIIFE: boolean;
           }>;
     }>
@@ -80,6 +86,9 @@ const schema: JSONSchema4 = [
                   type: "string",
                   enum: ["atLeastOne", "exactlyOne"],
                 },
+                ignoreLambdaExpression: {
+                  type: "boolean",
+                },
                 ignoreIIFE: {
                   type: "boolean",
                 },
@@ -103,6 +112,7 @@ const defaultOptions: Options = [
     allowArgumentsKeyword: false,
     enforceParameterCount: {
       count: "atLeastOne",
+      ignoreLambdaExpression: false,
       ignoreIIFE: true,
     },
   },
@@ -163,8 +173,8 @@ function getParamCountViolations(
     enforceParameterCount === false ||
     (node.params.length === 0 &&
       typeof enforceParameterCount === "object" &&
-      enforceParameterCount.ignoreIIFE &&
-      isIIFE(node))
+      ((enforceParameterCount.ignoreIIFE && isIIFE(node)) ||
+        (enforceParameterCount.ignoreLambdaExpression && isArgument(node))))
   ) {
     return [];
   }

diff --git a/src/util/tree.ts b/src/util/tree.ts
@@ -182,6 +182,18 @@ export function isIIFE(node: ReadonlyDeep<TSESTree.Node>): boolean {
   );
 }
 
+/**
+ * Is the given node being passed as an argument?
+ */
+export function isArgument(node: ReadonlyDeep<TSESTree.Node>): boolean {
+  return (
+    node.parent !== undefined &&
+    isCallExpression(node.parent) &&
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+    node.parent.arguments.includes(node as any)
+  );
+}
+
 /**
  * Get the key the given node is assigned to in its parent ObjectExpression.
  */

diff --git a/tests/rules/functional-parameters/es3/invalid.ts b/tests/rules/functional-parameters/es3/invalid.ts
@@ -130,6 +130,21 @@ const tests: ReadonlyArray<InvalidTestCase> = [
       },
     ],
   },
+  {
+    code: dedent`
+      function foo(param) {}
+      foo(function () {});
+    `,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "paramCountAtLeastOne",
+        type: "FunctionExpression",
+        line: 2,
+        column: 5,
+      },
+    ],
+  },
 ];
 
 export default tests;
diff --git a/tests/rules/functional-parameters/es3/valid.ts b/tests/rules/functional-parameters/es3/valid.ts
@@ -105,6 +105,13 @@ const tests: ReadonlyArray<ValidTestCase> = [
       ],
     ],
   },
+  {
+    code: dedent`
+      function foo(param) {}
+      foo(function () {});
+    `,
+    optionsSet: [[{ enforceParameterCount: { ignoreLambdaExpression: true } }]],
+  },
 ];
 
 export default tests;
diff --git a/tests/rules/functional-parameters/es6/invalid.ts b/tests/rules/functional-parameters/es6/invalid.ts
@@ -56,6 +56,21 @@ const tests: ReadonlyArray<InvalidTestCase> = [
       },
     ],
   },
+  {
+    code: dedent`
+      function foo(param) {}
+      foo(() => 1);
+    `,
+    optionsSet: [[]],
+    errors: [
+      {
+        messageId: "paramCountAtLeastOne",
+        type: "ArrowFunctionExpression",
+        line: 2,
+        column: 5,
+      },
+    ],
+  },
 ];
 
 export default tests;
diff --git a/tests/rules/functional-parameters/es6/valid.ts b/tests/rules/functional-parameters/es6/valid.ts
@@ -91,6 +91,13 @@ const tests: ReadonlyArray<ValidTestCase> = [
       ],
     ],
   },
+  {
+    code: dedent`
+      function foo(param) {}
+      foo(() => 1);
+    `,
+    optionsSet: [[{ enforceParameterCount: { ignoreLambdaExpression: true } }]],
+  },
 ];
 
 export default tests;