Merge branch 'main' into optimize-pipeline-for-complete-test-cases

Author: msyyc

.chronus/changes/fix-compiler-server-null-crashes-2026-4-30-7-30-0.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Fix server crashes caused by undefined symbol declarations: add null checks for `getSymNode()` in hover, completion, type-details, and type-signature handlers, and use fallback name for empty DocumentSymbol names

.chronus/changes/fix-lsp-unhandled-exceptions-2026-4-30-7-30-0.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - typespec-vscode
+---
+
+Handle unhandled exceptions in VS Code extension: add custom error handler for server crashes with restart notification, wrap commands with graceful exception handling, and add null guards to prevent extension host errors when LSP client is unavailable

.github/workflows/copilot-setup-steps.yml

@@ -21,6 +21,6 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v6
       - name: Install gh-aw extension
-        uses: github/gh-aw/actions/setup-cli@v0.71.1
+        uses: github/gh-aw/actions/setup-cli@v0.71.5
         with:
           version: v0.50.1

packages/compiler/src/server/completion.ts

@@ -421,20 +421,20 @@ async function addIdentifierCompletion(
     let kind: CompletionItemKind;
     let deprecated = false;
     const symNode = getSymNode(sym);
-    const type = sym.type ?? program.checker.getTypeForNode(symNode);
+    const type = sym.type ?? (symNode ? program.checker.getTypeForNode(symNode) : undefined);
     if (sym.flags & (SymbolFlags.Function | SymbolFlags.Decorator)) {
       kind = CompletionItemKind.Function;
     } else if (
       sym.flags & SymbolFlags.Namespace &&
-      symNode.kind !== SyntaxKind.NamespaceStatement
+      symNode?.kind !== SyntaxKind.NamespaceStatement
     ) {
       kind = CompletionItemKind.Module;
     } else if (symNode?.kind === SyntaxKind.AliasStatement) {
       kind = CompletionItemKind.Variable;
       deprecated = getDeprecationDetails(program, symNode) !== undefined;
     } else {
-      kind = getCompletionItemKind(program, type);
-      deprecated = getDeprecationDetails(program, type) !== undefined;
+      kind = type ? getCompletionItemKind(program, type) : CompletionItemKind.Variable;
+      deprecated = type ? getDeprecationDetails(program, type) !== undefined : false;
     }
     const documentation = await getSymbolDetails(program, sym);
 

packages/compiler/src/server/serverlib.ts

@@ -822,7 +822,7 @@ export function createServer(
       // Avoid showing full definition in other cases which can be long and not useful
       let includeExpandedDefinition = false;
       const sn = getSymNode(sym[0]);
-      if (sn.kind !== SyntaxKind.AliasStatement) {
+      if (sn && sn.kind !== SyntaxKind.AliasStatement) {
         const type = sym[0].type ?? program.checker.getTypeOrValueForNode(sn);
         if (type && "kind" in type) {
           const modelHasExtendOrIs: boolean =

packages/compiler/src/server/symbol-structure.ts

@@ -109,7 +109,10 @@ export function getSymbolStructure(ast: TypeSpecScriptNode): DocumentSymbol[] {
     const start = file.getLineAndCharacterOfPosition(node.pos);
     const end = file.getLineAndCharacterOfPosition(node.end);
     const range = Range.create(start, end);
-    return DocumentSymbol.create(name, undefined, kind, range, range, symbols);
+    // VS Code requires name to be non-empty; use a placeholder for empty/invalid names
+    // that can occur during parse errors or with empty string literal properties.
+    const safeName = name || "<anonymous>";
+    return DocumentSymbol.create(safeName, undefined, kind, range, range, symbols);
   }
 
   function getName(id: IdentifierNode | StringLiteralNode): string {

packages/compiler/src/server/type-details.ts

@@ -80,9 +80,12 @@ function getSymbolDocumentation(program: Program, symbol: Sym) {
   // Add @doc(...) API docs
   let type = symbol.type;
   if (!type) {
-    const entity = program.checker.getTypeOrValueForNode(getSymNode(symbol));
-    if (entity && isType(entity)) {
-      type = entity;
+    const symNode = getSymNode(symbol);
+    if (symNode) {
+      const entity = program.checker.getTypeOrValueForNode(symNode);
+      if (entity && isType(entity)) {
+        type = entity;
+      }
     }
   }
   if (type) {

packages/compiler/src/server/type-signature.ts

@@ -46,7 +46,7 @@ export async function getSymbolSignature(
     case SyntaxKind.AliasStatement:
       return fence(`alias ${await getAliasSignature(decl)}`);
   }
-  const entity = sym.type ?? program.checker.getTypeOrValueForNode(decl);
+  const entity = sym.type ?? (decl ? program.checker.getTypeOrValueForNode(decl) : null);
   return getEntitySignature(sym, entity, options);
 }
 

packages/typespec-vscode/src/extension.ts

@@ -126,6 +126,13 @@ export async function activate(context: ExtensionContext) {
                 async (tel): Promise<ResultCode> => {
                   return await emitCode(context, uri, tel);
                 },
+                undefined,
+                (e) => {
+                  logger.error("Unexpected error when emitting code from TypeSpec.", [e], {
+                    showPopup: true,
+                  });
+                  return ResultCode.Fail;
+                },
               );
             },
           );
@@ -165,6 +172,14 @@ export async function activate(context: ExtensionContext) {
                     }
                   },
                   args?.activityId,
+                  (e) => {
+                    logger.error(
+                      "Unexpected error when restarting TypeSpec language server.",
+                      [e],
+                      { showPopup: true },
+                    );
+                    return { code: ResultCode.Fail };
+                  },
                 );
               },
             );
@@ -198,7 +213,26 @@ export async function activate(context: ExtensionContext) {
           await telemetryClient.doOperationWithTelemetry(
             TelemetryEventName.PreviewOpenApi3,
             async (tel): Promise<ResultCode> => {
-              return await showOpenApi3(uri, context, tspLanguageClient!, tel);
+              if (!tspLanguageClient || tspLanguageClient.state !== State.Running) {
+                logger.error(
+                  "TypeSpec language server is not running. Please restart the server.",
+                  [],
+                  { showPopup: true },
+                );
+                telemetryClient.logOperationDetailTelemetry(tel.activityId, {
+                  error: "LSP client is not running",
+                });
+                tel.lastStep = "Check LSP client";
+                return ResultCode.Fail;
+              }
+              return await showOpenApi3(uri, context, tspLanguageClient, tel);
+            },
+            undefined,
+            (e) => {
+              logger.error("Unexpected error when previewing OpenAPI3.", [e], {
+                showPopup: true,
+              });
+              return ResultCode.Fail;
             },
           );
         }),
@@ -213,6 +247,13 @@ export async function activate(context: ExtensionContext) {
               async (tel) => {
                 return await recreateLSPClient(context, tel.activityId);
               },
+              undefined,
+              (e) => {
+                logger.error("Unexpected error when restarting server after path change.", [e], {
+                  showPopup: true,
+                });
+                return { code: ResultCode.Fail };
+              },
             );
           }
         }),
@@ -318,14 +359,30 @@ export async function activate(context: ExtensionContext) {
             return installResult.code;
           },
           tel.activityId,
+          (e) => {
+            logger.error("Unexpected error when starting TypeSpec language server.", [e], {
+              showPopup: true,
+            });
+            return ResultCode.Fail;
+          },
         );
       } else {
         logger.info("No workspace opened, Skip starting TypeSpec language service.");
+        telemetryClient.logOperationDetailTelemetry(tel.activityId, {
+          compilerLocation: "skipped-no-workspace-or-tsp-file",
+        });
       }
       showStartUpMessages(stateManager);
       telemetryClient.sendDelayedTelemetryEvents();
       return ResultCode.Success;
     },
+    undefined,
+    (e) => {
+      logger.error("Unexpected error when starting TypeSpec extension.", [e], {
+        showPopup: true,
+      });
+      return ResultCode.Fail;
+    },
   );
 
   // Expose API for other extensions to consume
@@ -339,36 +396,52 @@ export async function activate(context: ExtensionContext) {
 }
 
 export async function deactivate() {
-  await tspLanguageClient?.stop();
-  await clearOpenApi3PreviewTempFolders();
+  try {
+    await tspLanguageClient?.stop();
+    await clearOpenApi3PreviewTempFolders();
+  } catch (e) {
+    logger.error("Error during extension deactivation", [e]);
+  }
 }
 
 async function recreateLSPClient(
   context: ExtensionContext,
   activityId: string,
 ): Promise<Result<TspLanguageClient>> {
-  logger.info("Recreating TypeSpec LSP server...");
-  const oldClient = tspLanguageClient;
-  setTspLanguageClient(await TspLanguageClient.create(activityId, context, outputChannel));
-  await oldClient?.stop();
-  if (!tspLanguageClient) {
-    telemetryClient.logOperationDetailTelemetry(activityId, {
-      error: "Failed to create TspLanguageClient",
-    });
-    return { code: ResultCode.Fail, details: "Failed to create TspLanguageClient." };
-  } else {
-    await tspLanguageClient.start(activityId);
-    if (tspLanguageClient.state === State.Running) {
+  try {
+    logger.info("Recreating TypeSpec LSP server...");
+    const oldClient = tspLanguageClient;
+    setTspLanguageClient(await TspLanguageClient.create(activityId, context, outputChannel));
+    await oldClient?.stop();
+    if (!tspLanguageClient) {
       telemetryClient.logOperationDetailTelemetry(activityId, {
-        compilerVersion: tspLanguageClient.initializeResult?.serverInfo?.version ?? "< 0.64.0",
+        error: "Failed to create TspLanguageClient. Compiler could not be resolved.",
       });
-      return { code: ResultCode.Success, value: tspLanguageClient };
+      return { code: ResultCode.Fail, details: "Failed to create TspLanguageClient." };
     } else {
-      telemetryClient.logOperationDetailTelemetry(activityId, {
-        error: `Failed to start TspLanguageClient.`,
-      });
-      return { code: ResultCode.Fail, details: "TspLanguageClient is not running." };
+      await tspLanguageClient.start(activityId);
+      if (tspLanguageClient.state === State.Running) {
+        telemetryClient.logOperationDetailTelemetry(activityId, {
+          compilerVersion: tspLanguageClient.initializeResult?.serverInfo?.version ?? "< 0.64.0",
+        });
+        return { code: ResultCode.Success, value: tspLanguageClient };
+      } else {
+        telemetryClient.logOperationDetailTelemetry(activityId, {
+          error: `Failed to start TspLanguageClient. State: ${tspLanguageClient.state}`,
+        });
+        return { code: ResultCode.Fail, details: "TspLanguageClient is not running." };
+      }
     }
+  } catch (e) {
+    logger.error(
+      "TypeSpec language server is unavailable due to an unexpected error. Please restart the server.",
+      [e],
+      { showPopup: true },
+    );
+    telemetryClient.logOperationDetailTelemetry(activityId, {
+      error: `Unexpected error in recreateLSPClient: ${e}`,
+    });
+    return { code: ResultCode.Fail, details: `Unexpected error: ${e}` };
   }
 }
 

packages/typespec-vscode/src/telemetry/telemetry-client.ts

@@ -120,6 +120,13 @@ export class TelemetryClient {
       sendTelemetryEvent: (result: ResultCode, delay: boolean) => void,
     ) => Promise<T>,
     activityId?: string,
+    /**
+     * Optional callback to handle unhandled exceptions from the operation.
+     * If provided, the exception will NOT be re-thrown and this callback will be invoked instead,
+     * and its return value will be used as the result of the operation.
+     * If not provided, the exception will be re-thrown after telemetry logging (default behavior).
+     */
+    onUnhandledException?: (error: unknown) => T,
   ): Promise<T> {
     const opTelemetryEvent = this.createOperationTelemetryEvent(eventName, activityId);
     let eventSent = false;
@@ -149,6 +156,9 @@ export class TelemetryClient {
         error: "Unhandled exception from operation to doOperationWithTelemetry: \n" + inspect(e),
       });
       opTelemetryEvent.result = ResultCode.Fail;
+      if (onUnhandledException) {
+        return onUnhandledException(e);
+      }
       // just report the issue in telemetry and re-throw the error
       throw e;
     } finally {