Remove other cancel handling.

Author: sean-mcmanus

Extension/src/LanguageServer/client.ts

@@ -804,9 +804,9 @@ export interface Client {
     getShowConfigureIntelliSenseButton(): boolean;
     setShowConfigureIntelliSenseButton(show: boolean): void;
     addTrustedCompiler(path: string): Promise<void>;
-    getIncludes(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult>;
+    getIncludes(maxDepth: number): Promise<GetIncludesResult>;
     getChatContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ChatContextResult>;
-    getProjectContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ProjectContextResult>;
+    getProjectContext(uri: vscode.Uri): Promise<ProjectContextResult>;
 }
 
 export function createClient(workspaceFolder?: vscode.WorkspaceFolder): Client {
@@ -2228,11 +2228,10 @@ export class DefaultClient implements Client {
         await this.languageClient.sendNotification(DidOpenNotification, params);
     }
 
-    public async getIncludes(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult> {
+    public async getIncludes(maxDepth: number): Promise<GetIncludesResult> {
         const params: GetIncludesParams = { maxDepth: maxDepth };
         await this.ready;
-        return DefaultClient.withLspCancellationHandling(
-            () => this.languageClient.sendRequest(IncludesRequest, params, token), token);
+        return this.languageClient.sendRequest(IncludesRequest, params);
     }
 
     public async getChatContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ChatContextResult> {
@@ -2242,11 +2241,10 @@ export class DefaultClient implements Client {
             () => this.languageClient.sendRequest(CppContextRequest, params, token), token);
     }
 
-    public async getProjectContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ProjectContextResult> {
+    public async getProjectContext(uri: vscode.Uri): Promise<ProjectContextResult> {
         const params: TextDocumentIdentifier = { uri: uri.toString() };
-        await withCancellation(this.ready, token);
-        return DefaultClient.withLspCancellationHandling(
-            () => this.languageClient.sendRequest(ProjectContextRequest, params, token), token);
+        await this.ready;
+        return this.languageClient.sendRequest(ProjectContextRequest, params);
     }
 
     /**
@@ -2340,11 +2338,8 @@ export class DefaultClient implements Client {
                 throw e;
             }
         }
-
-        // Don't cancel if the result has already been computed, because the result might still be usable
-        // without needing to send an unnecessary re-request, which is the case for the callback to registerRelatedFilesProvider.
         if (token.isCancellationRequested) {
-            return result; // throw new vscode.CancellationError();
+            throw new vscode.CancellationError();
         }
 
         return result;
@@ -4153,7 +4148,7 @@ class NullClient implements Client {
     getShowConfigureIntelliSenseButton(): boolean { return false; }
     setShowConfigureIntelliSenseButton(show: boolean): void { }
     addTrustedCompiler(path: string): Promise<void> { return Promise.resolve(); }
-    getIncludes(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult> { return Promise.resolve({} as GetIncludesResult); }
+    getIncludes(maxDepth: number): Promise<GetIncludesResult> { return Promise.resolve({} as GetIncludesResult); }
     getChatContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ChatContextResult> { return Promise.resolve({} as ChatContextResult); }
-    getProjectContext(uri: vscode.Uri, token: vscode.CancellationToken): Promise<ProjectContextResult> { return Promise.resolve({} as ProjectContextResult); }
+    getProjectContext(uri: vscode.Uri): Promise<ProjectContextResult> { return Promise.resolve({} as ProjectContextResult); }
 }

Extension/src/LanguageServer/copilotProviders.ts

@@ -38,14 +38,14 @@ export async function registerRelatedFilesProvider(): Promise<void> {
             for (const languageId of ['c', 'cpp', 'cuda-cpp']) {
                 api.registerRelatedFilesProvider(
                     { extensionId: util.extensionContext.extension.id, languageId },
-                    async (uri: vscode.Uri, context: { flags: Record<string, unknown> }, token: vscode.CancellationToken) => {
+                    async (uri: vscode.Uri, context: { flags: Record<string, unknown> }) => {
                         const start = performance.now();
                         const telemetryProperties: Record<string, string> = {};
                         const telemetryMetrics: Record<string, number> = {};
                         try {
-                            const getIncludesHandler = async () => (await getIncludesWithCancellation(1, token))?.includedFiles.map(file => vscode.Uri.file(file)) ?? [];
+                            const getIncludesHandler = async () => (await getIncludes(1))?.includedFiles.map(file => vscode.Uri.file(file)) ?? [];
                             const getTraitsHandler = async () => {
-                                const projectContext = await getProjectContext(uri, context, token);
+                                const projectContext = await getProjectContext(uri, context);
 
                                 if (!projectContext) {
                                     return undefined;
@@ -154,9 +154,9 @@ export async function registerRelatedFilesProvider(): Promise<void> {
     }
 }
 
-async function getIncludesWithCancellation(maxDepth: number, token: vscode.CancellationToken): Promise<GetIncludesResult> {
+async function getIncludes(maxDepth: number): Promise<GetIncludesResult> {
     const activeClient = getActiveClient();
-    const includes = await activeClient.getIncludes(maxDepth, token);
+    const includes = await activeClient.getIncludes(maxDepth);
     const wksFolder = activeClient.RootUri?.toString();
 
     if (!wksFolder) {

Extension/src/LanguageServer/lmTool.ts

@@ -127,11 +127,11 @@ function filterCompilerArguments(compiler: string, compilerArguments: string[],
     return result;
 }
 
-export async function getProjectContext(uri: vscode.Uri, context: { flags: Record<string, unknown> }, token: vscode.CancellationToken): Promise<ProjectContext | undefined> {
+export async function getProjectContext(uri: vscode.Uri, context: { flags: Record<string, unknown> }): Promise<ProjectContext | undefined> {
     const telemetryProperties: Record<string, string> = {};
     const telemetryMetrics: Record<string, number> = {};
     try {
-        const projectContext = await checkDuration<ProjectContextResult | undefined>(async () => await getClients()?.ActiveClient?.getProjectContext(uri, token) ?? undefined);
+        const projectContext = await checkDuration<ProjectContextResult | undefined>(async () => await getClients()?.ActiveClient?.getProjectContext(uri) ?? undefined);
         telemetryMetrics["duration"] = projectContext.duration;
         if (!projectContext.result) {
             return undefined;

Extension/test/scenarios/SingleRootProject/tests/lmTool.test.ts

@@ -130,17 +130,17 @@ describe('CppConfigurationLanguageModelTool Tests', () => {
     });
 
     const arrangeChatContextFromCppTools = ({ chatContextFromCppTools, isCpp, isHeaderFile }:
-    { chatContextFromCppTools?: ChatContextResult; isCpp?: boolean; isHeaderFile?: boolean } =
-    { chatContextFromCppTools: undefined, isCpp: undefined, isHeaderFile: false }
+        { chatContextFromCppTools?: ChatContextResult; isCpp?: boolean; isHeaderFile?: boolean } =
+        { chatContextFromCppTools: undefined, isCpp: undefined, isHeaderFile: false }
     ) => {
         activeClientStub.getChatContext.resolves(chatContextFromCppTools);
         sinon.stub(util, 'isCpp').returns(isCpp ?? true);
         sinon.stub(util, 'isHeaderFile').returns(isHeaderFile ?? false);
     };
 
     const arrangeProjectContextFromCppTools = ({ projectContextFromCppTools, isCpp, isHeaderFile }:
-    { projectContextFromCppTools?: ProjectContextResult; isCpp?: boolean; isHeaderFile?: boolean } =
-    { projectContextFromCppTools: undefined, isCpp: undefined, isHeaderFile: false }
+        { projectContextFromCppTools?: ProjectContextResult; isCpp?: boolean; isHeaderFile?: boolean } =
+        { projectContextFromCppTools: undefined, isCpp: undefined, isHeaderFile: false }
     ) => {
         activeClientStub.getProjectContext.resolves(projectContextFromCppTools);
         sinon.stub(util, 'isCpp').returns(isCpp ?? true);
@@ -200,7 +200,7 @@ describe('CppConfigurationLanguageModelTool Tests', () => {
             }
         });
 
-        const result = await getProjectContext(mockTextDocumentStub.uri, context, new vscode.CancellationTokenSource().token);
+        const result = await getProjectContext(mockTextDocumentStub.uri, context);
 
         ok(result, 'result should not be undefined');
         ok(result.language === 'C++');
@@ -364,7 +364,7 @@ describe('CppConfigurationLanguageModelTool Tests', () => {
             }
         });
 
-        const result = await getProjectContext(mockTextDocumentStub.uri, { flags: {} }, new vscode.CancellationTokenSource().token);
+        const result = await getProjectContext(mockTextDocumentStub.uri, { flags: {} });
 
         ok(telemetryStub.calledOnce, 'Telemetry should be called once');
         ok(telemetryStub.calledWithMatch('ProjectContext', sinon.match({