feat(strict-void-return): sync overload-safe callback typing with upstream

Author: camc314

internal/rule_tester/__snapshots__/strict-void-return.snap

@@ -1206,3 +1206,12 @@ Message: Value-returning function used in a context where a void function is exp
      |          ~~
    6 | });
 ---
+
+[TestStrictVoidReturnRule/invalid-109 - 1]
+Diagnostic 1: nonVoidReturn (4:20 - 4:25)
+Message: Value returned in a context where a void return is expected.
+   3 | 
+   4 | f(undefined, () => 'test');
+     |                    ~~~~~~
+   5 |       
+---

internal/rules/strict_void_return/strict_void_return.go

@@ -60,6 +60,21 @@ var StrictVoidReturnRule = rule.Rule{
 			})
 		}
 
+		isNullishOrAny := func(t *checker.Type) bool {
+			return utils.IsTypeFlagSet(
+				t,
+				checker.TypeFlagsVoidLike|
+					checker.TypeFlagsUndefined|
+					checker.TypeFlagsNull|
+					checker.TypeFlagsAny|
+					checker.TypeFlagsNever,
+			)
+		}
+
+		isVoid := func(t *checker.Type) bool {
+			return utils.IsTypeFlagSet(t, checker.TypeFlagsVoid)
+		}
+
 		var reportIfNonVoidFunction func(funcNode *ast.Node)
 		reportIfNonVoidFunction = func(funcNode *ast.Node) {
 			actualType := checker.Checker_getApparentType(ctx.TypeChecker, ctx.TypeChecker.GetTypeAtLocation(funcNode))
@@ -145,10 +160,6 @@ var StrictVoidReturnRule = rule.Rule{
 					continue
 				}
 
-				if checkExpressionNode(argNode) {
-					continue
-				}
-
 				argExpectedReturnTypes := []*checker.Type{}
 				for _, sig := range signatures {
 					parameters := checker.Signature_parameters(sig)
@@ -163,24 +174,16 @@ var StrictVoidReturnRule = rule.Rule{
 					}
 				}
 
-				if len(argExpectedReturnTypes) == 0 {
+				hasSingleSignature := len(signatures) == 1
+				allSignaturesReturnVoid := utils.Every(argExpectedReturnTypes, func(returnType *checker.Type) bool {
+					return isVoid(returnType) || isNullishOrAny(returnType) || utils.IsTypeParameter(returnType)
+				})
+
+				if (hasSingleSignature || allSignaturesReturnVoid) && checkExpressionNode(argNode) {
 					continue
 				}
 
-				anyVoid := utils.Some(argExpectedReturnTypes, func(returnType *checker.Type) bool {
-					return utils.IsTypeFlagSet(returnType, checker.TypeFlagsVoid)
-				})
-				allVoidLike := utils.Every(argExpectedReturnTypes, func(returnType *checker.Type) bool {
-					return utils.IsTypeFlagSet(
-						returnType,
-						checker.TypeFlagsVoidLike|
-							checker.TypeFlagsUndefined|
-							checker.TypeFlagsNull|
-							checker.TypeFlagsAny|
-							checker.TypeFlagsNever,
-					)
-				})
-				if anyVoid && allVoidLike {
+				if utils.Some(argExpectedReturnTypes, isVoid) && utils.Every(argExpectedReturnTypes, isNullishOrAny) {
 					reportIfNonVoidFunction(argNode)
 				}
 			}

internal/rules/strict_void_return/strict_void_return_test.go

@@ -212,13 +212,27 @@ new Foo(() => false);
 			Code: `
 declare function foo(cb: () => boolean): void;
 declare function foo(cb: () => void): void;
+foo(() => false);
+      `,
+		},
+		{
+			Code: `
+declare function foo(cb: () => void): void;
+declare function foo(cb: () => boolean): void;
 foo(() => false);
       `,
 		},
 		{
 			Code: `
 declare function foo(cb: () => Promise<void>): void;
 declare function foo(cb: () => void): void;
+foo(async () => {});
+      `,
+		},
+		{
+			Code: `
+declare function foo(fn: () => void): void;
+declare function foo(fn: () => Promise<void>): void;
 foo(async () => {});
       `,
 		},
@@ -917,6 +931,30 @@ foo((arg: number) => {
 function cb() {
   return true;
 }
+      `,
+		},
+		{
+			Code: `
+declare function f<T extends void>(arg: T, cb: () => T): void;
+declare function f<T extends string>(arg: T, cb: () => T): void;
+
+f('test', () => 'test');
+f(undefined, () => {});
+      `,
+		},
+		{
+			Code: `
+interface HookFunction<T extends void | Hook = void> {
+  (fn: () => void): T;
+  (fn: () => Promise<void>): T;
+}
+
+class Hook {}
+
+declare var beforeEach: HookFunction<Hook>;
+
+beforeEach(() => {});
+beforeEach(async () => {});
       `,
 		},
 	}
@@ -2316,6 +2354,16 @@ async function* cb() {
 				{MessageId: "nonVoidFunc", Line: 5},
 			},
 		},
+		{
+			Code: `
+declare function f<T extends void>(arg: T, cb: () => T): void;
+
+f(undefined, () => 'test');
+      `,
+			Errors: []rule_tester.InvalidTestCaseError{
+				{MessageId: "nonVoidReturn", Line: 4},
+			},
+		},
 	}
 
 	rule_tester.RunRuleTester(fixtures.GetRootDir(), "tsconfig.minimal.json", t, &StrictVoidReturnRule, validCases, invalidCases)