Fixed a crash in completions on functionlike types (#56257)

src/compiler/checker.ts

@@ -469,6 +469,7 @@ import {
     isCallChain,
     isCallExpression,
     isCallLikeExpression,
+    isCallLikeOrFunctionLikeExpression,
     isCallOrNewExpression,
     isCallSignatureDeclaration,
     isCatchClause,
@@ -1837,23 +1838,35 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     };
 
     function runWithoutResolvedSignatureCaching<T>(node: Node | undefined, fn: () => T): T {
-        const cachedSignatures = [];
-        while (node) {
-            if (isCallLikeExpression(node)) {
+        node = findAncestor(node, isCallLikeOrFunctionLikeExpression);
+        if (node) {
+            const cachedResolvedSignatures = [];
+            const cachedTypes = [];
+            while (node) {
                 const nodeLinks = getNodeLinks(node);
-                const resolvedSignature = nodeLinks.resolvedSignature;
-                cachedSignatures.push([nodeLinks, resolvedSignature] as const);
+                cachedResolvedSignatures.push([nodeLinks, nodeLinks.resolvedSignature] as const);
                 nodeLinks.resolvedSignature = undefined;
+                if (isFunctionExpressionOrArrowFunction(node)) {
+                    const symbolLinks = getSymbolLinks(getSymbolOfDeclaration(node));
+                    const type = symbolLinks.type;
+                    cachedTypes.push([symbolLinks, type] as const);
+                    symbolLinks.type = undefined;
+                }
+                node = findAncestor(node.parent, isCallLikeOrFunctionLikeExpression);
             }
-            node = node.parent;
-        }
-        const result = fn();
-        for (const [nodeLinks, resolvedSignature] of cachedSignatures) {
-            nodeLinks.resolvedSignature = resolvedSignature;
+            const result = fn();
+            for (const [nodeLinks, resolvedSignature] of cachedResolvedSignatures) {
+                nodeLinks.resolvedSignature = resolvedSignature;
+            }
+            for (const [symbolLinks, type] of cachedTypes) {
+                symbolLinks.type = type;
+            }
+            return result;
         }
-        return result;
+        return fn();
     }
 
+
     function runWithInferenceBlockedFromSourceNode<T>(node: Node | undefined, fn: () => T): T {
         const containingCall = findAncestor(node, isCallLikeExpression);
         if (containingCall) {

src/compiler/utilitiesPublic.ts

@@ -5,6 +5,7 @@ import {
     ArrayBindingElement,
     ArrayBindingOrAssignmentElement,
     ArrayBindingOrAssignmentPattern,
+    ArrowFunction,
     AssertionExpression,
     AssertionKey,
     AssignmentDeclarationKind,
@@ -65,6 +66,7 @@ import {
     ForInitializer,
     ForInOrOfStatement,
     FunctionBody,
+    FunctionExpression,
     FunctionLikeDeclaration,
     FunctionTypeNode,
     GeneratedIdentifier,
@@ -116,6 +118,7 @@ import {
     isExportSpecifier,
     isFunctionBlock,
     isFunctionExpression,
+    isFunctionExpressionOrArrowFunction,
     isFunctionTypeNode,
     isIdentifier,
     isImportSpecifier,
@@ -1917,6 +1920,11 @@ export function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAcc
         || kind === SyntaxKind.QualifiedName;
 }
 
+/** @internal */
+export function isCallLikeOrFunctionLikeExpression(node: Node): node is CallLikeExpression | FunctionExpression | ArrowFunction {
+    return isCallLikeExpression(node) || isFunctionExpressionOrArrowFunction(node);
+}
+
 export function isCallLikeExpression(node: Node): node is CallLikeExpression {
     switch (node.kind) {
         case SyntaxKind.JsxOpeningElement:

tests/cases/fourslash/jsDocFunctionTypeCompletionsNoCrash.ts

@@ -0,0 +1,13 @@
+///<reference path="fourslash.ts" />
+
+//// /**
+////  * @returns {function/**/(): string}
+////  */
+//// function updateCalendarEvent() {
+////   return "";
+//// }
+
+verify.completions({
+    marker: "",
+    exact: completion.globalTypes
+});