feat(eslint-plugin): [promise-function-async] Allow any and unknown as return values

packages/eslint-plugin/docs/rules/promise-function-async.md

@@ -36,6 +36,7 @@ async function functionDeturnsPromise() {
 
 Options may be provided as an object with:
 
+- `allowAny` to indicate that `any` or `unknown` shouldn't be considered Promises (`false` by default).
 - `allowedPromiseNames` to indicate any extra names of classes or interfaces to be considered Promises when returned.
 
 In addition, each of the following properties may be provided, and default to `true`:
@@ -50,6 +51,7 @@ In addition, each of the following properties may be provided, and default to `t
   "@typescript-eslint/promise-function-async": [
     "error",
     {
+      "allowAny": true,
       "allowedPromiseNames": ["Thenable"],
       "checkArrowFunctions": true,
       "checkFunctionDeclarations": true,

packages/eslint-plugin/src/rules/promise-function-async.ts

@@ -3,6 +3,7 @@ import * as util from '../util';
 
 type Options = [
   {
+    allowAny?: boolean;
     allowedPromiseNames?: string[];
     checkArrowFunctions?: boolean;
     checkFunctionDeclarations?: boolean;
@@ -29,6 +30,9 @@ export default util.createRule<Options, MessageIds>({
       {
         type: 'object',
         properties: {
+          allowAny: {
+            type: 'boolean',
+          },
           allowedPromiseNames: {
             type: 'array',
             items: {
@@ -54,6 +58,7 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [
     {
+      allowAny: false,
       allowedPromiseNames: [],
       checkArrowFunctions: true,
       checkFunctionDeclarations: true,
@@ -65,6 +70,7 @@ export default util.createRule<Options, MessageIds>({
     context,
     [
       {
+        allowAny,
         allowedPromiseNames,
         checkArrowFunctions,
         checkFunctionDeclarations,
@@ -90,7 +96,9 @@ export default util.createRule<Options, MessageIds>({
       }
       const returnType = checker.getReturnTypeOfSignature(signatures[0]);
 
-      if (!util.containsTypeByName(returnType, allAllowedPromiseNames)) {
+      if (
+        !util.containsTypeByName(returnType, allowAny!, allAllowedPromiseNames)
+      ) {
         return;
       }
 

packages/eslint-plugin/src/util/types.ts

@@ -13,10 +13,11 @@ import ts from 'typescript';
  */
 export function containsTypeByName(
   type: ts.Type,
+  allowAny: boolean,
   allowedNames: Set<string>,
 ): boolean {
   if (isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
-    return true;
+    return !allowAny;
   }
 
   if (isTypeReference(type)) {
@@ -31,13 +32,13 @@ export function containsTypeByName(
   }
 
   if (isUnionOrIntersectionType(type)) {
-    return type.types.some(t => containsTypeByName(t, allowedNames));
+    return type.types.some(t => containsTypeByName(t, allowAny, allowedNames));
   }
 
   const bases = type.getBaseTypes();
   return (
     typeof bases !== 'undefined' &&
-    bases.some(t => containsTypeByName(t, allowedNames))
+    bases.some(t => containsTypeByName(t, allowAny, allowedNames))
   );
 }
 

packages/eslint-plugin/tests/rules/promise-function-async.test.ts

@@ -30,7 +30,6 @@ const asyncPromiseFunctionExpressionB = async function() { return new Promise<vo
     `
 class Test {
   public nonAsyncNonPromiseArrowFunction = (n: number) => n;
-
   public nonAsyncNonPromiseMethod() {
     return 0;
   }
@@ -71,10 +70,58 @@ const invalidAsyncModifiers = {
     `export function valid(n: number) { return n; }`,
     `export default function invalid(n: number) { return n; }`,
     `class Foo { constructor() { } }`,
+    {
+      code: `
+function returnsAny(): any {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
+    {
+      code: `
+function returnsUnknown(): unknown {
+  return 0;
+}
+      `,
+      options: [
+        {
+          allowAny: true,
+        },
+      ],
+    },
   ],
   invalid: [
     {
       code: `
+function returnsAny(): any {
+  return 0;
+}
+      `,
+      errors: [
+        {
+          messageId,
+        },
+      ],
+    },
+    {
+      code: `
+function returnsUnknown(): unknown {
+  return 0;
+}
+      `,
+      errors: [
+        {
+          messageId,
+        },
+      ],
+    },
+    {
+      code: `
 const nonAsyncPromiseFunctionExpressionA = function(p: Promise<void>) { return p; };
             `,
       errors: [