Update API changes that add methods with command result information (#4518)

* Update api

temp

* update to execute clean, install, and reconfigure with results

* implement listBuildTargets

* implement run ctest with result api

* add todo for the tests parameter

* implemented ctestWithResult and listTests, may need additional testing but seems to work from an API perspective in a small test project and also CMake repo

* add cancellation token support in api updates

* slightly modify to old status for methods that were unchanged

* add api telemetry

* add version

* enforce better lifetime for combinedCancellationTokens

* add comment, no need for engine update, and remove unnecessary test change

* missed @types/vscode update

* update methods, add comments explaining, switch to exitCode

* update comment

* update vscode-cmake-tools npm package

* some linter fixes

* some more linter fixes

* linter

* linter

* remove unused imports

* fix test referencing result instead of exitCode

* linter

* update tests to reference exitCode rather than CommandResult return value

* keep unofficial api the same

Author: gcampbell-msft

package.json

@@ -3848,7 +3848,7 @@
     "tsconfig-paths": "^3.11.0",
     "tslint": "^6.1.3",
     "typescript": "^4.1.5",
-    "vscode-cmake-tools": "^1.2.0",
+    "vscode-cmake-tools": "^1.3.0",
     "vscode-nls-dev": "^3.3.2",
     "webpack": "^5.94.0",
     "webpack-cli": "^4.5.0"

src/api.ts

@@ -8,17 +8,21 @@ import * as api from 'vscode-cmake-tools';
 import CMakeProject from '@cmt/cmakeProject';
 import { ExtensionManager } from '@cmt/extension';
 import { assertNever } from '@cmt/util';
+import { CTestOutputLogger } from '@cmt/ctest';
+import { logEvent } from './telemetry';
 
 export class CMakeToolsApiImpl implements api.CMakeToolsApi {
     constructor(private readonly manager: ExtensionManager) {}
 
-    version: api.Version = api.Version.v2;
+    version: api.Version = api.Version.v4;
 
     showUIElement(element: api.UIElement): Promise<void> {
+        logApiTelemetry('showUIElement');
         return this.setUIElementVisibility(element, true);
     }
 
     hideUIElement(element: api.UIElement): Promise<void> {
+        logApiTelemetry('hideUIElement');
         return this.setUIElementVisibility(element, false);
     }
 
@@ -35,11 +39,13 @@ export class CMakeToolsApiImpl implements api.CMakeToolsApi {
     }
 
     async getProject(uri: vscode.Uri): Promise<CMakeProjectWrapper | undefined> {
+        logApiTelemetry('getProject');
         const project: CMakeProject | undefined = await this.manager.projectController.getProjectForFolder(uri.fsPath);
         return project ? new CMakeProjectWrapper(project) : undefined;
     }
 
     getActiveFolderPath(): string {
+        logApiTelemetry('getActiveFolderPath');
         return this.manager.activeFolderPath();
     }
 
@@ -57,10 +63,10 @@ export class CMakeToolsApiImpl implements api.CMakeToolsApi {
     }
 }
 
-async function withErrorCheck(name: string, action: () => Promise<number>): Promise<void> {
+async function withErrorCheck(name: string, action: () => Promise<api.CommandResult>): Promise<void> {
     const code = await action();
-    if (code !== 0) {
-        throw new Error(`${name} failed with code ${code}`);
+    if (code.exitCode !== 0) {
+        throw new Error(`${name} failed with code ${code.exitCode}, stdout: ${code.stdout ?? ''}, stderr: ${code.stderr ?? ''}`);
     }
 }
 
@@ -80,30 +86,83 @@ class CMakeProjectWrapper implements api.Project {
     }
 
     configure(): Promise<void> {
-        return withErrorCheck('configure', async () => (await this.project.configure()).result);
+        logApiTelemetry('configure');
+        return withErrorCheck('configure', async () => (this.project.configure()));
+    }
+
+    async configureWithResult(cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('configureWithResult');
+        return this.project.configure(undefined, cancellationToken);
     }
 
     build(targets?: string[]): Promise<void> {
+        logApiTelemetry('build');
         return withErrorCheck('build', () => this.project.build(targets));
     }
 
+    async buildWithResult(targets?: string[], cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('buildWithResult');
+        return this.project.build(targets, undefined, undefined, cancellationToken);
+    }
+
+    async ctestWithResult(tests?: string[], cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('ctestWithResult');
+        return this.project.ctest(undefined, new CTestOutputLogger(), tests, cancellationToken);
+    }
+
     install(): Promise<void> {
+        logApiTelemetry('install');
         return withErrorCheck('install', () => this.project.install());
     }
 
+    installWithResult(cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('installWithResult');
+        return this.project.install(cancellationToken);
+    }
+
     clean(): Promise<void> {
+        logApiTelemetry('clean');
         return withErrorCheck('clean', () => this.project.clean());
     }
 
+    async cleanWithResult(cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('cleanWithResult');
+        return this.project.clean(cancellationToken);
+    }
+
     reconfigure(): Promise<void> {
-        return withErrorCheck('reconfigure', async () => (await this.project.cleanConfigure()).result);
+        logApiTelemetry('reconfigure');
+        return withErrorCheck('reconfigure', async () => (this.project.cleanConfigure()));
+    }
+
+    async reconfigureWithResult(cancellationToken?: vscode.CancellationToken): Promise<api.CommandResult> {
+        logApiTelemetry('reconfigureWithResult');
+        return this.project.cleanConfigure(undefined, cancellationToken);
     }
 
     async getBuildDirectory(): Promise<string | undefined> {
+        logApiTelemetry('getBuildDirectory');
         return (await this.project.buildDirectory()) ?? undefined;
     }
 
     async getActiveBuildType(): Promise<string | undefined> {
+        logApiTelemetry('getActiveBuildType');
         return (await this.project.currentBuildType()) ?? undefined;
     }
+
+    async listBuildTargets(): Promise<string[] | undefined> {
+        logApiTelemetry('listBuildTargets');
+        return (await this.project.targets).map(target => target.name);
+    }
+
+    async listTests(): Promise<string[] | undefined> {
+        logApiTelemetry('listTests');
+        return this.project.cTestController.getTestNames();
+    }
+}
+
+function logApiTelemetry(method: string): void {
+    logEvent("api", {
+        method: method
+    });
 }