typescript-eslint · JoshuaKGoldberg · Sep 29, 2024 · Sep 23, 2024 · Sep 23, 2024 · Sep 25, 2024
diff --git a/packages/eslint-plugin/src/rules/no-misused-promises.ts b/packages/eslint-plugin/src/rules/no-misused-promises.ts
@@ -743,6 +743,20 @@ function checkThenableOrVoidArgument(
   ) {
     voidReturnIndices.add(index);
   }
+  const contextualType = checker.getContextualTypeForArgumentAtIndex(
+    node,
+    index,
+  );
+  if (contextualType !== type) {
+    checkThenableOrVoidArgument(
+      checker,
+      node,
+      contextualType,
+      index,
+      thenableReturnIndices,
+      voidReturnIndices,
+    );
+  }
 }
 
 // Get the positions of arguments which are void functions (and not also

diff --git a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
@@ -1051,6 +1051,21 @@ interface MyInterface extends MyCall, MyIndex, MyConstruct, MyMethods {
 const array: number[] = [1, 2, 3];
 array.filter(a => a > 1);
     `,
+    `
+type ReturnsPromiseVoid = () => Promise<void>;
+declare const useCallback: <T extends (...args: unknown[]) => unknown>(
+  fn: T,
+) => T;
+useCallback<ReturnsPromiseVoid>(async () => {});
+    `,
+    `
+type ReturnsVoid = () => void;
+type ReturnsPromiseVoid = () => Promise<void>;
+declare const useCallback: <T extends (...args: unknown[]) => unknown>(
+  fn: T,
+) => T;
+useCallback<ReturnsVoid | ReturnsPromiseVoid>(async () => {});
+    `,
   ],
 
   invalid: [
@@ -2322,5 +2337,97 @@ tuple.find(() => Promise.resolve(false));
         },
       ],
     },
+    {
+      code: `
+type ReturnsVoid = () => void;
+declare const useCallback: <T extends (...args: unknown[]) => unknown>(
+  fn: T,
+) => T;
+declare const useCallbackReturningVoid: typeof useCallback<ReturnsVoid>;
+useCallbackReturningVoid(async () => {});
+      `,
+      errors: [
+        {
+          line: 7,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+type ReturnsVoid = () => void;
+declare const useCallback: <T extends (...args: unknown[]) => unknown>(
+  fn: T,
+) => T;
+useCallback<ReturnsVoid>(async () => {});
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+interface Foo<T> {
+  (callback: () => T): void;
+  (callback: () => number): void;
+}
+declare const foo: Foo<void>;
+
+foo(async () => {});
+      `,
+      errors: [
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+declare function tupleFn<T extends (...args: unknown[]) => unknown>(
+  ...fns: [T, string, T]
+): void;
+tupleFn<() => void>(
+  async () => {},
+  'foo',
+  async () => {},
+);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
+    {
+      code: `
+declare function arrayFn<T extends (...args: unknown[]) => unknown>(
+  ...fns: (T | string)[]
+): void;
+arrayFn<() => void>(
+  async () => {},
+  'foo',
+  async () => {},
+);
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId: 'voidReturnArgument',
+        },
+        {
+          line: 8,
+          messageId: 'voidReturnArgument',
+        },
+      ],
+    },
   ],
 });