fix(no-floating-promises): avoid recursive checker calls

Author: camc314

internal/rule_tester/__snapshots__/no-floating-promises.snap

@@ -1684,3 +1684,26 @@ Help: The promise must end with a call to .catch, or end with a call to .then wi
   Suggestion 1: [floatingFixVoid] Add void operator to ignore.
   Suggestion 2: [floatingFixAwait] Add await operator.
 ---
+
+[TestNoFloatingPromisesRule/invalid-101 - 1]
+Diagnostic 1: floatingVoid (14:9 - 20:13)
+Message: Promises must be awaited, add void operator to ignore.
+Help: The promise must end with a call to .catch, or end with a call to .then with a rejection handler, or be explicitly marked as ignored with the `void` operator.
+  13 | 
+  14 |         (async () => {
+     |         ~~~~~~~~~~~~~~
+  15 |           wrapNode(() => {
+     | ~~~~~~~~~~~~~~~~~~~~~~~~~~
+  16 |             const node = createNode();
+     | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  17 | 
+  18 |             return wrapNode<typeof node.getNextNode<any>>(node.getNextNode);
+     | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  19 |           });
+     | ~~~~~~~~~~~~~
+  20 |         })();
+     | ~~~~~~~~~~~~~
+  21 |       
+  Suggestion 1: [floatingFixVoid] Add void operator to ignore.
+  Suggestion 2: [floatingFixAwait] Add await operator.
+---

internal/rules/no_floating_promises/no_floating_promises.go

@@ -256,6 +256,48 @@ var NoFloatingPromisesRule = rule.Rule{
 			return true
 		}
 
+		isFunctionExpression := func(node *ast.Node) bool {
+			return ast.IsArrowFunction(node) || ast.IsFunctionExpression(node)
+		}
+
+		skipOuterExpressions := func(node *ast.Node) *ast.Node {
+			return ast.SkipOuterExpressions(node, ast.OEKAll)
+		}
+
+		isAsyncIifeCall := func(node *ast.Node) bool {
+			if !ast.IsCallExpression(node) {
+				return false
+			}
+			callee := skipOuterExpressions(node.AsCallExpression().Expression)
+			return isFunctionExpression(callee) && ast.IsAsyncFunction(callee)
+		}
+
+		getStaticPropertyName := func(node *ast.Node) string {
+			if !ast.IsPropertyAccessExpression(node) {
+				return ""
+			}
+			return node.AsPropertyAccessExpression().Name().Text()
+		}
+
+		var containsTypeArgumentCall func(node *ast.Node) bool
+		containsTypeArgumentCall = func(node *ast.Node) bool {
+			if ast.IsCallExpression(node) && node.AsCallExpression().TypeArguments != nil {
+				return true
+			}
+			return node.ForEachChild(func(child *ast.Node) bool {
+				return containsTypeArgumentCall(child)
+			})
+		}
+
+		containsFunctionArgumentWithTypeArgumentCall := func(callExpr *ast.CallExpression) bool {
+			for _, arg := range callExpr.Arguments.Nodes {
+				if isFunctionExpression(arg) && containsTypeArgumentCall(arg) {
+					return true
+				}
+			}
+			return false
+		}
+
 		var isUnhandledPromise func(
 			node *ast.Node,
 		) (
@@ -293,6 +335,44 @@ var NoFloatingPromisesRule = rule.Rule{
 				return isUnhandledPromise(node.Expression())
 			}
 
+			if ast.IsCallExpression(node) {
+				callExpr := node.AsCallExpression()
+				callee := skipOuterExpressions(callExpr.Expression)
+
+				if isAsyncIifeCall(node) {
+					return true, false, false
+				}
+
+				if ast.IsAccessExpression(callee) && isAsyncIifeCall(callee.Expression()) {
+					switch getStaticPropertyName(callee) {
+					case "catch":
+						if !isKnownArgumentAt(callExpr.Arguments, 0) {
+							return true, false, false
+						}
+						if isFunctionExpression(callExpr.Arguments.Nodes[0]) {
+							return false, false, false
+						}
+						return true, true, false
+					case "then":
+						if !isKnownArgumentAt(callExpr.Arguments, 1) {
+							return true, false, false
+						}
+						if isFunctionExpression(callExpr.Arguments.Nodes[1]) {
+							return false, false, false
+						}
+						return true, true, false
+					case "finally":
+						return isUnhandledPromise(callee.Expression())
+					}
+				}
+
+				// typescript-go can recurse indefinitely when resolving some generic
+				// calls inside callback return types.
+				if containsFunctionArgumentWithTypeArgumentCall(callExpr) {
+					return false, false, false
+				}
+			}
+
 			// Check the type. At this point it can't be unhandled if it isn't a promise
 			// or array thereof.
 

internal/rules/no_floating_promises/no_floating_promises_test.go

@@ -807,7 +807,6 @@ myAsyncFunction();
 			Options: rule_tester.OptionsFromJSON[NoFloatingPromisesOptions](`{"allowForKnownSafeCalls": ["myAsyncFunction"]}`),
 		},
 		{
-			Skip: true,
 			Code: `
       interface CustomNode<P> {
         getNextNode: () => CustomNode<P>;
@@ -5606,7 +5605,6 @@ await Promise.reject('foo').then(...[], () => {});
 			},
 		},
 		{
-			Skip: true,
 			Code: `
         interface CustomNode<P> {
           getNextNode: () => CustomNode<P>;