Fix compiler crash on generics overload resolution failure reported by #61524

Replace `Debug.fail()` calls with proper error generation to prevent TypeScript
compiler crashes when overload resolution fails for complex generic constraints,
for example JSX elements.

Problem
--

The TypeScript compiler crashes with "Debug Failure. No error for last overload
signature" when resolving certain complex generic constraints, e.g., JSX element
types. This regression has existed since TypeScript 3.6 and affects many React/JSX
projects.

Root Cause
--

When `getSignatureApplicabilityError()` returns no diagnostics for overload
candidates, the compiler calls `Debug.fail()` instead of handling the edge case
gracefully, causing an immediate crash.

Solution
--

- Replace `Debug.fail()` calls with fallback diagnostic generation
- Generate appropriate error messages for unhandled overload resolution cases
- Ensure compiler continues execution without crashing

Related to #61524, #60229, #48636, #33133

Signed-off-by: moznion <[email protected]>

Author: moznion

src/compiler/checker.ts

@@ -36603,7 +36603,22 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         }
                     }
                     else {
-                        Debug.fail("No error for last overload signature");
+                        // Fallback: Generate a generic error when no specific error can be determined
+                        // This replaces the Debug.fail() to prevent compiler crashes
+                        // See: https://github.com/microsoft/TypeScript/issues/61524
+                        const fallbackChain = chainDiagnosticMessages(
+                            /*details*/ undefined,
+                            Diagnostics.No_overload_matches_this_call,
+                        );
+                        const errorNode = getErrorNodeForCallNode(node);
+                        const fallbackDiag = createDiagnosticForNodeFromMessageChain(
+                            getSourceFileOfNode(errorNode),
+                            errorNode,
+                            fallbackChain,
+                            /*relatedInformation*/ undefined,
+                        );
+
+                        diagnostics.add(fallbackDiag);
                     }
                 }
                 else {
@@ -36624,7 +36639,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                             allDiagnostics.push(diags);
                         }
                         else {
-                            Debug.fail("No error for 3 or fewer overload signatures");
+                            // Fallback: Generate a generic error for this overload candidate
+                            // This prevents crashes when processing multiple overload signatures
+                            const fallbackChain = chainDiagnosticMessages(
+                                /*details*/ undefined,
+                                Diagnostics.Overload_0_of_1_2_gave_the_following_error,
+                                i + 1,
+                                candidates.length,
+                                signatureToString(c),
+                            );
+                            const errorNode = getErrorNodeForCallNode(node);
+                            const fallbackDiag = createDiagnosticForNodeFromMessageChain(
+                                getSourceFileOfNode(errorNode),
+                                errorNode,
+                                fallbackChain,
+                                /*relatedInformation*/ undefined,
+                            );
+                            allDiagnostics.push([fallbackDiag]);
                         }
                         i++;
                     }