Consider GNATtest project attributes in VS Code integration

Author: eliericha

integration/vscode/ada/src/ExtensionState.ts

@@ -1,3 +1,5 @@
+import { existsSync } from 'fs';
+import path, { isAbsolute } from 'path';
 import * as vscode from 'vscode';
 import {
     Disposable,
@@ -6,14 +8,19 @@ import {
 } from 'vscode-languageclient/node';
 import { AdaCodeLensProvider } from './AdaCodeLensProvider';
 import { AdaLanguageClient, createClient } from './clients';
+import {
+    CMD_RELOAD_PROJECT,
+    CMD_RESTART_LANG_SERVERS,
+    CMD_SHOW_ADA_LS_OUTPUT,
+    CMD_SHOW_EXTENSION_LOGS,
+    CMD_SHOW_GPR_LS_OUTPUT,
+} from './commands';
 import { AdaInitialDebugConfigProvider, initializeDebugging } from './debugConfigProvider';
 import { logger } from './extension';
-import { existsSync } from 'fs';
-import path from 'path';
 import { GnatTaskProvider } from './gnatTaskProvider';
 import { initializeTesting } from './gnattest';
 import { GprTaskProvider } from './gprTaskProvider';
-import { getArgValue, TERMINAL_ENV_SETTING_NAME, exe, getEvaluatedTerminalEnv } from './helpers';
+import { TERMINAL_ENV_SETTING_NAME, exe, getArgValue, getEvaluatedTerminalEnv } from './helpers';
 import {
     SimpleTaskDef,
     SimpleTaskProvider,
@@ -22,14 +29,6 @@ import {
     createAdaTaskProvider,
     createSparkTaskProvider,
 } from './taskProviders';
-import { isAbsolute } from 'path';
-import {
-    CMD_SHOW_EXTENSION_LOGS,
-    CMD_SHOW_ADA_LS_OUTPUT,
-    CMD_SHOW_GPR_LS_OUTPUT,
-    CMD_RELOAD_PROJECT,
-    CMD_RESTART_LANG_SERVERS,
-} from './commands';
 
 /**
  * Return type of the 'als-source-dirs' LSP request.
@@ -78,6 +77,7 @@ export class ExtensionState {
     cachedAlireTomls: vscode.Uri[] | undefined;
     cachedDebugServerAddress: string | undefined | null;
     cachedGdb: string | undefined | null = undefined;
+    projectAttributeCache: Map<string, Promise<string | string[]>> = new Map();
 
     private adaTaskProvider?: SimpleTaskProvider;
     private sparkTaskProvider?: SimpleTaskProvider;
@@ -92,6 +92,7 @@ export class ExtensionState {
         this.cachedAlireTomls = undefined;
         this.cachedDebugServerAddress = undefined;
         this.cachedGdb = undefined;
+        this.projectAttributeCache.clear();
     }
 
     constructor(context: vscode.ExtensionContext) {
@@ -367,35 +368,60 @@ export class ExtensionState {
      * an exception when the queried attribute is not known
      * (i.e: not registered in GPR2's knowledge database).
      *
+     * Query results are cached by default so that querying the same attribute
+     * multiple times will result in only one request to the server.
+     *
      * @param attribute - The name of the project attribute (e.g: 'Target')
      * @param pkg - The name of the attribute's package (e.g: 'Compiler').
      * Can be empty for project-level attributes.
      * @param index - Attribute's index, if any. Can be a file or a language
      * (e.g: 'for Runtime ("Ada") use...').
+     * @param useCache - whether to use cached result from previous query. If
+     * set to false, the request will be sent to the server and the result will
+     * be used to update the cache. This allows refreshing a particular project
+     * attribute in the cache.
      * @returns the value of the queried project attribute. Can be either a string or a
      * list of strings, depending on the attribute itself (e.g: 'Main' attribute is
      * specified as a list of strings while 'Target' as a string)
      */
-    public async getProjectAttributeValue(
+    public getProjectAttributeValue(
         attribute: string,
         pkg: string = '',
         index: string = '',
+        useCache = true,
     ): Promise<string | string[]> {
-        const params: ExecuteCommandParams = {
-            command: 'als-get-project-attribute-value',
-            arguments: [
-                {
-                    attribute: attribute,
-                    pkg: pkg,
-                    index: index,
-                },
-            ],
+        const queryArgs = {
+            attribute: attribute,
+            pkg: pkg,
+            index: index,
         };
 
-        const attrValue = (await this.adaClient.sendRequest(ExecuteCommandRequest.type, params)) as
-            | string
-            | string[];
-        return attrValue;
+        /**
+         * In the JS Map class, keys are compared using something equivalent to
+         * ===. So two distinct objects with the same deep content will
+         * constitute different keys. A common way of using objects as Map keys
+         * is to stringify them.
+         */
+        const mapKey = JSON.stringify(queryArgs);
+        const cachedPromise = useCache ? this.projectAttributeCache.get(mapKey) : undefined;
+
+        if (cachedPromise === undefined) {
+            const params: ExecuteCommandParams = {
+                command: 'als-get-project-attribute-value',
+                arguments: [queryArgs],
+            };
+
+            const queryPromise = this.adaClient.sendRequest(
+                ExecuteCommandRequest.type,
+                params,
+            ) as Promise<string | string[]>;
+
+            this.projectAttributeCache.set(mapKey, queryPromise);
+
+            return queryPromise;
+        } else {
+            return cachedPromise;
+        }
     }
 
     /**
@@ -648,6 +674,15 @@ export class ExtensionState {
     public getAdaTaskProvider() {
         return this.adaTaskProvider;
     }
+
+    /**
+     *
+     * @returns path under the project object dir where the VS Code extension can
+     * store temporary state
+     */
+    public async getVSCodeObjectSubdir(): Promise<string> {
+        return path.join(await this.getObjectDir(), 'vscode-ada');
+    }
 }
 
 /**

integration/vscode/ada/src/gnattest.ts

@@ -9,11 +9,10 @@ import { CancellationToken } from 'vscode-languageclient';
 import { adaExtState } from './extension';
 import { addCoverageData, GnatcovFileCoverage } from './gnatcov';
 import { getScenarioArgs } from './gnatTaskProvider';
-import { escapeRegExp, exe, getObjectDir, setTerminalEnvironment, slugify } from './helpers';
+import { escapeRegExp, exe, setTerminalEnvironment, slugify } from './helpers';
 import {
     DEFAULT_PROBLEM_MATCHER,
     findTaskByName,
-    runTaskAndGetResult,
     runTaskSequence,
     SimpleTaskDef,
     TASK_BUILD_TEST_DRIVER,
@@ -160,19 +159,29 @@ export async function refreshTestItemTree() {
 /**
  * @returns the full path to the GNATtest XML file.
  */
-async function getGnatTestXmlPath(): Promise<string> {
-    const objDir = await getObjectDir();
-    const gnatTestXmlPath = path.join(objDir, 'gnattest', 'harness', 'gnattest.xml');
+export async function getGnatTestXmlPath(): Promise<string> {
+    const gnatTestXmlPath = path.join(await getHarnessDir(), 'gnattest.xml');
     return gnatTestXmlPath;
 }
 
+export async function getHarnessDir() {
+    return await adaExtState
+        .getProjectAttributeValue('Harness_Dir', 'Gnattest')
+        .catch(
+            /**
+             * default to gnattest/harness if Harness_Dir is unspecified
+             */
+            () => path.join('gnattest', 'harness'),
+        )
+        .then(async (value) => path.join(await adaExtState.getObjectDir(), value as string));
+}
+
 /**
  *
  * @returns the full path to the GNATtest test driver GPR project.
  */
 export async function getGnatTestDriverProjectPath(): Promise<string> {
-    const objDir = await getObjectDir();
-    const testDriverPath = path.join(objDir, 'gnattest', 'harness', 'test_driver.gpr');
+    const testDriverPath = path.join(await getHarnessDir(), 'test_driver.gpr');
     return testDriverPath;
 }
 
@@ -181,11 +190,26 @@ export async function getGnatTestDriverProjectPath(): Promise<string> {
  * @returns the full path to the GNATtest test driver executable.
  */
 export async function getGnatTestDriverExecPath(): Promise<string> {
-    const objDir = await getObjectDir();
-    const testDriverPath = path.join(objDir, 'gnattest', 'harness', 'test_runner' + exe);
+    const testDriverPath = path.join(await getHarnessDir(), 'test_runner' + exe);
     return testDriverPath;
 }
 
+/**
+ *
+ * @returns path where GNATcoverage execution traces will be created during a test run
+ */
+async function getTracesDir() {
+    return path.join(await adaExtState.getVSCodeObjectSubdir(), 'test-traces');
+}
+
+/**
+ *
+ * @returns path where GNATcoverage report will be created after a test run
+ */
+async function getGnatCovXMLReportDir() {
+    return path.join(await adaExtState.getVSCodeObjectSubdir(), 'cov-xml');
+}
+
 /**
  * Parse the GNATtest XML file and create the top-level TestItems in the test
  * controller for later lazy resolution.
@@ -330,6 +354,7 @@ async function addTestCaseItem(parentItem: vscode.TestItem, testCase: TestCase)
     const testFileBasename = test['@_file'];
     const pos = new vscode.Position(parseInt(test['@_line']), parseInt(test['@_column']) - 1);
     const range = new vscode.Range(pos, pos);
+
     const testUri = await findFileInWorkspace(testFileBasename);
 
     // The name of the source file of the tested subprogram is not part of the
@@ -557,7 +582,16 @@ async function handleRunRequestedTests(
             requestedRootTests.push(...request.include);
         } else {
             /**
-             * Consider all tests as included
+             * If the Testing view hasn't been opened yet, the tests may not
+             * have been loaded yet. Check for that and load the tests in that
+             * case.
+             */
+            if (controller.items.size == 0) {
+                await refreshTestItemTree();
+            }
+
+            /**
+             * Consider all tests as included.
              */
             controller.items.forEach((i) => requestedRootTests.push(i));
         }
@@ -606,7 +640,11 @@ async function handleRunRequestedTests(
          * Invoke the test driver for each test
          */
         const execPath = await getGnatTestDriverExecPath();
-        const tracesDir = path.dirname(execPath);
+        const tracesDir = await getTracesDir();
+
+        if (coverage) {
+            fs.mkdirSync(tracesDir, { recursive: true });
+        }
 
         function getTracePath(test: TestItem): string {
             return path.join(tracesDir, slugify(test.id) + '.srctrace');
@@ -684,7 +722,7 @@ async function handleRunRequestedTests(
             /**
              * Produce a GNATcov XML report
              */
-            const outputDir = path.join(await adaExtState.getObjectDir(), 'cov-xml');
+            const outputDir = await getGnatCovXMLReportDir();
             const adaTP = adaExtState.getAdaTaskProvider()!;
             const gnatcovReportTask = (await adaTP.resolveTask(
                 new vscode.Task(
@@ -708,7 +746,7 @@ async function handleRunRequestedTests(
                 ),
             ))!;
             gnatcovReportTask.presentationOptions.reveal = vscode.TaskRevealKind.Never;
-            const result = await runTaskAndGetResult(gnatcovReportTask);
+            const result = await runTaskSequence([gnatcovReportTask], new WriteEmitter(run));
             if (result != 0) {
                 const msg =
                     `Error while running coverage analysis.` +
@@ -726,6 +764,20 @@ async function handleRunRequestedTests(
     }
 }
 
+/**
+ * An EventEmitter that forwards data to a a TestRun given at construction
+ * time.
+ */
+class WriteEmitter extends vscode.EventEmitter<string> {
+    constructor(private run: vscode.TestRun) {
+        super();
+    }
+
+    override fire(data: string): void {
+        this.run.appendOutput(data);
+    }
+}
+
 /**
  * Build the test driver and report build failure as errors on the tests
  * requested for execution.
@@ -739,12 +791,6 @@ async function buildTestDriverAndReportErrors(
     testsToRun: vscode.TestItem[],
     coverage: boolean,
 ) {
-    class WriteEmitter extends vscode.EventEmitter<string> {
-        override fire(data: string): void {
-            run.appendOutput(data);
-        }
-    }
-
     const buildTasks = [];
     if (coverage) {
         const adaTP = adaExtState.getAdaTaskProvider();
@@ -836,7 +882,7 @@ async function buildTestDriverAndReportErrors(
         buildTasks.push(task);
     }
 
-    const result = await runTaskSequence(buildTasks, new WriteEmitter());
+    const result = await runTaskSequence(buildTasks, new WriteEmitter(run));
 
     if (result != 0) {
         let msg =