Treat errors on updateOpen as non-recoverable

Any errors on `updateOpen` will cause the TS Server to become out of sync. This change alerts us to errors that happen in `updateOpen`. We then restart the ts server

Author: mjbvz

extensions/typescript-language-features/src/features/bufferSyncSupport.ts

@@ -8,6 +8,7 @@ import * as Proto from '../protocol';
 import { ITypeScriptServiceClient } from '../typescriptService';
 import API from '../utils/api';
 import { Delayer } from '../utils/async';
+import { nulToken } from '../utils/cancellation';
 import { Disposable } from '../utils/dispose';
 import * as languageModeIds from '../utils/languageModeIds';
 import { ResourceMap } from '../utils/resourceMap';
@@ -142,7 +143,7 @@ class BufferSynchronizer {
 					case 'close': closedFiles.push(change.args); break;
 				}
 			}
-			this.client.executeWithoutWaitingForResponse('updateOpen', { changedFiles, closedFiles, openFiles });
+			this.client.execute('updateOpen', { changedFiles, closedFiles, openFiles }, nulToken, { nonRecoverable: true });
 			this._pending.clear();
 		}
 	}

extensions/typescript-language-features/src/typescriptService.ts

@@ -57,13 +57,13 @@ interface StandardTsServerRequests {
 	'selectionRange': [Proto.SelectionRangeRequestArgs, Proto.SelectionRangeResponse];
 	'signatureHelp': [Proto.SignatureHelpRequestArgs, Proto.SignatureHelpResponse];
 	'typeDefinition': [Proto.FileLocationRequestArgs, Proto.TypeDefinitionResponse];
+	'updateOpen': [Proto.UpdateOpenRequestArgs, Proto.Response];
 }
 
 interface NoResponseTsServerRequests {
 	'open': [Proto.OpenRequestArgs, null];
-	'close': [Proto.FileRequestArgs];
+	'close': [Proto.FileRequestArgs, null];
 	'change': [Proto.ChangeRequestArgs, null];
-	'updateOpen': [Proto.UpdateOpenRequestArgs, null];
 	'compilerOptionsForInferredProjects': [Proto.SetCompilerOptionsForInferredProjectsArgs, null];
 	'reloadProjects': [null, null];
 	'configurePlugin': [Proto.ConfigurePluginRequest, Proto.ConfigurePluginResponse];
@@ -76,7 +76,8 @@ interface AsyncTsServerRequests {
 export type TypeScriptRequests = StandardTsServerRequests & NoResponseTsServerRequests & AsyncTsServerRequests;
 
 export type ExecConfig = {
-	lowPriority?: boolean;
+	readonly lowPriority?: boolean;
+	readonly nonRecoverable?: boolean;
 };
 
 export interface ITypeScriptServiceClient {
@@ -138,4 +139,4 @@ export interface ITypeScriptServiceClient {
 	 * Cancel on going geterr requests and re-queue them after `f` has been evaluated.
 	 */
 	interruptGetErr<R>(f: () => R): R;
-}
+}

extensions/typescript-language-features/src/typescriptServiceClient.ts

@@ -611,12 +611,18 @@ export default class TypeScriptServiceClient extends Disposable implements IType
 	}
 
 	public execute(command: keyof TypeScriptRequests, args: any, token: vscode.CancellationToken, config?: ExecConfig): Promise<ServerResponse.Response<Proto.Response>> {
-		return this.executeImpl(command, args, {
+		const execution = this.executeImpl(command, args, {
 			isAsync: false,
 			token,
 			expectsResult: true,
 			lowPriority: config ? config.lowPriority : undefined
 		});
+
+		if (config?.nonRecoverable) {
+			execution.catch(() => this.fatalError(command));
+		}
+
+		return execution;
 	}
 
 	public executeWithoutWaitingForResponse(command: keyof TypeScriptRequests, args: any): void {
@@ -647,6 +653,21 @@ export default class TypeScriptServiceClient extends Disposable implements IType
 		return this.bufferSyncSupport.interuptGetErr(f);
 	}
 
+	private fatalError(command: string): void {
+		/* __GDPR__
+			"fatalError" : {
+				"${include}": [
+					"${TypeScriptCommonProperties}",
+					"command" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
+				]
+			}
+		*/
+		this.logTelemetry('fatalError', { command });
+		console.error(`A non-recoverable error occured while executing tsserver command: ${command}`);
+
+		this.restartTsServer();
+	}
+
 	private dispatchEvent(event: Proto.Event) {
 		switch (event.event) {
 			case 'syntaxDiag':