feat(eslint-plugin): [explicit-function-return-type] allowHigherOrderFunctions (#193)

packages/eslint-plugin/docs/rules/explicit-function-return-type.md

@@ -67,11 +67,14 @@ type Options = {
   allowExpressions?: boolean;
   // if true, type annotations are also allowed on the variable of a function expression rather than on the function directly.
   allowTypedFunctionExpressions?: boolean;
+  // if true, only arrow functions which does not return an arrow function will be checked
+  allowCurrying?: boolean;
 };
 
 const defaults = {
   allowExpressions: false,
   allowTypedFunctionExpressions: false,
+  allowCurrying: false,
 };
 ```
 
@@ -137,6 +140,20 @@ let objectPropCast = <ObjectType>{
 };
 ```
 
+### allowCurrying
+
+Examples of **incorrect** code for this rule with `{ allowCurrying: true }`:
+
+```ts
+var curriedAddFn = (x: number) => (y: number) => x + y;
+```
+
+Examples of **correct** code for this rule with `{ allowCurrying: true }`:
+
+```ts
+var curriedAddFn = (x: number) => (y: number): number => x + y;
+```
+
 ## When Not To Use It
 
 If you don't wish to prevent calling code from using function return values in unexpected ways, then

packages/eslint-plugin/src/rules/explicit-function-return-type.ts

@@ -8,6 +8,7 @@ type Options = [
   {
     allowExpressions?: boolean;
     allowTypedFunctionExpressions?: boolean;
+    allowCurrying?: boolean;
   }
 ];
 type MessageIds = 'missingReturnType';
@@ -35,6 +36,9 @@ export default util.createRule<Options, MessageIds>({
           allowTypedFunctionExpressions: {
             type: 'boolean',
           },
+          allowCurrying: {
+            type: 'boolean',
+          },
         },
         additionalProperties: false,
       },
@@ -44,6 +48,7 @@ export default util.createRule<Options, MessageIds>({
     {
       allowExpressions: false,
       allowTypedFunctionExpressions: false,
+      allowCurrying: false,
     },
   ],
   create(context, [options]) {
@@ -188,6 +193,14 @@ export default util.createRule<Options, MessageIds>({
         ) {
           return;
         }
+
+        if (
+          options.allowCurrying &&
+          node.type === AST_NODE_TYPES.ArrowFunctionExpression &&
+          node.body.type === AST_NODE_TYPES.ArrowFunctionExpression
+        ) {
+          return;
+        }
       }
 
       checkFunctionReturnType(node);

packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts

@@ -180,6 +180,13 @@ const myObj = {
 };
       `,
     },
+    {
+      filename: 'test.ts',
+      code: `
+var curriedAddFn = (x: int) => (y: int): int => x + y;
+            `,
+      options: [{ allowCurrying: true }],
+    },
   ],
   invalid: [
     {
@@ -364,5 +371,38 @@ const x: Foo = {
         },
       ],
     },
+    {
+      filename: 'test.ts',
+      code: `
+var curriedAddFn = (x: number) => (y: number) => x + y;
+            `,
+      options: [{ allowCurrying: false }],
+      errors: [
+        {
+          messageId: 'missingReturnType',
+          line: 2,
+          column: 20,
+        },
+        {
+          messageId: 'missingReturnType',
+          line: 2,
+          column: 35,
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+var curriedAddFn = (x: number) => (y: number) => x + y;
+            `,
+      options: [{ allowCurrying: true }],
+      errors: [
+        {
+          messageId: 'missingReturnType',
+          line: 2,
+          column: 35,
+        },
+      ],
+    },
   ],
 });