Merge remote branch 'origin/master' into edge

Author: automatic-merge

Diff for: integration/vscode/ada/src/ExtensionState.ts

@@ -190,6 +190,9 @@ export class ExtensionState {
      * diagnostics.
      */
     public updateStatusBarItem = () => {
+        // Set the status bar item's default text ('Ada & SPARK')
+        this.statusBar.text = 'Ada & SPARK';
+
         // Use markdown for the status bar item tiooltip. This allows to have
         // hyperlinks that run actual commands.
         this.statusBar.tooltip = new vscode.MarkdownString('', true);
@@ -220,7 +223,6 @@ export class ExtensionState {
             const statusBarSeverity: vscode.DiagnosticSeverity = alsDiagnostics
                 .map((a) => a.severity)
                 .reduce((a, b) => (a < b ? a : b));
-            this.statusBar.text = 'Ada & SPARK';
 
             switch (statusBarSeverity) {
                 case vscode.DiagnosticSeverity.Error:

Diff for: integration/vscode/ada/src/gnatcov.ts

@@ -1,11 +1,12 @@
+import assert from 'assert';
 import { X2jOptions, XMLParser } from 'fast-xml-parser';
 import * as fs from 'fs';
+import { cpus } from 'os';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { CancellationToken } from 'vscode-languageclient';
-import { parallelize, staggerProgress } from './helpers';
-import { cpus } from 'os';
-import { assert } from 'console';
+import { adaExtState } from './extension';
+import { getMatchingPrefixes, parallelize, staggerProgress, toPosix } from './helpers';
 
 /**
  * TypeScript types to represent data from GNATcoverage XML reports
@@ -299,25 +300,109 @@ export async function addCoverageData(run: vscode.TestRun, covDir: string) {
             progress.report({
                 message: `${done} / ${totalFiles} source files`,
             });
+
+            let posixForeignPrefix: string | undefined;
+            let posixLocalPrefix: string | undefined;
+
+            const procs = process.env.PROCESSORS ? Number(process.env.PROCESSORS) : 0;
             const fileCovs = (
                 await parallelize(
                     array,
-                    Math.min(cpus().length, 8),
+                    Math.min(procs == 0 ? cpus().length : procs, 8),
                     async (file) => {
                         if (token.isCancellationRequested) {
                             throw new vscode.CancellationError();
                         }
 
                         assert(file['@_name']);
+                        const foreignPath = file['@_name'];
+                        /**
+                         * The foreign machine may have a different path
+                         * format, so we normalize to POSIX which is valid on
+                         * both Windows and POSIX OS-es.
+                         */
+                        const posixForeignPath = toPosix(foreignPath);
 
-                        let srcUri: vscode.Uri;
-                        if (path.isAbsolute(file['@_name']!)) {
-                            srcUri = vscode.Uri.file(file['@_name']!);
-                        } else {
+                        let srcUri: vscode.Uri | undefined = undefined;
+
+                        /**
+                         * The goal here is to find the file in the workspace
+                         * corresponding to the name attribute in the GNATcov
+                         * report.
+                         *
+                         * The name could be a basename (older GNATcov
+                         * versions) or an absolute path (newer GNATcov
+                         * versions).
+                         *
+                         * In the case of a basename, the only course of action
+                         * is to do a file lookup in the workspace.
+                         *
+                         * In the case of an absolute path, the path
+                         * corresponds to the machine where the report was
+                         * created which might be a foreign machine or the
+                         * local host. We can't know in which situation we are
+                         * so it's best to assume that it's a foreign machine.
+                         *
+                         * Then the logic consists of searching for the first
+                         * file by basename, which gives a local absolute path.
+                         * Then by comparing the local absolute path and the
+                         * foreign absolute path, we can find a foreign prefix
+                         * path that should be mapped to the local prefix path
+                         * to compute local absolute paths. Subsequent files
+                         * can use the computed prefixes directly without a
+                         * workspace lookup.
+                         */
+
+                        if (path.posix.isAbsolute(posixForeignPath)) {
+                            let localFullPath;
+                            if (posixLocalPrefix && posixForeignPrefix) {
+                                /**
+                                 * The prefixes have already been determined, so
+                                 * use them directly.
+                                 */
+
+                                if (posixForeignPath.startsWith(posixForeignPrefix)) {
+                                    // Extract the relative path based on the foreign prefix
+                                    const posixForeignRelPath = path.relative(
+                                        posixForeignPrefix,
+                                        posixForeignPath,
+                                    );
+
+                                    // Resolve the relative path with the local prefix
+                                    localFullPath = path.join(
+                                        posixLocalPrefix,
+                                        posixForeignRelPath,
+                                    );
+                                }
+                            }
+
+                            // Fallback to using the input path as is
+                            localFullPath = localFullPath ?? foreignPath;
+
+                            if (fs.existsSync(localFullPath)) {
+                                srcUri = vscode.Uri.file(localFullPath);
+                            }
+                        }
+
+                        if (srcUri === undefined) {
+                            /**
+                             * If the prefixes haven't been found yet, or
+                             * the last prefixes used were not successful,
+                             * try a workspace lookup of the basename.
+                             */
                             const found = await vscode.workspace.findFiles(
-                                `**/${file['@_name']!}`,
-                                null,
+                                `**/${path.posix.basename(posixForeignPath)}`,
+                                /**
+                                 * Avoid searching in the object dir because we
+                                 * might land on gnatcov-instrumented versions
+                                 * of the sources.
+                                 */
+                                `${await adaExtState
+                                    .getObjectDir()
+                                    .then((objDir) => `${objDir}/**/*`)
+                                    .catch(() => null)}`,
                                 1,
+                                token,
                             );
                             if (found.length == 0) {
                                 return undefined;
@@ -326,6 +411,27 @@ export async function addCoverageData(run: vscode.TestRun, covDir: string) {
                             srcUri = found[0];
                         }
 
+                        if (
+                            posixForeignPrefix === undefined &&
+                            posixLocalPrefix === undefined &&
+                            path.posix.isAbsolute(posixForeignPath)
+                        ) {
+                            /**
+                             * If the prefixes haven't been calculated, and the
+                             * foreign path is absolute, let's try to compute
+                             * the prefixes based on the workspace URI that was
+                             * found.
+                             */
+
+                            const localAbsPath = srcUri.fsPath;
+                            const posixLocalAbsPath = toPosix(localAbsPath);
+
+                            [posixForeignPrefix, posixLocalPrefix] = getMatchingPrefixes(
+                                posixForeignPath,
+                                posixLocalAbsPath,
+                            );
+                        }
+
                         const total = file.metric.find(
                             (m) => m['@_kind'] == 'total_lines_of_relevance',
                         )!['@_count'];
@@ -334,14 +440,15 @@ export async function addCoverageData(run: vscode.TestRun, covDir: string) {
                         ];
 
                         const fileReportBasename = data.coverage_report.sources!['xi:include'].find(
-                            (inc) => inc['@_href'] == `${path.basename(file['@_name']!)}.xml`,
+                            (inc) =>
+                                inc['@_href'] == `${path.posix.basename(posixForeignPath)}.xml`,
                         )!['@_href'];
                         const fileReportPath = path.join(covDir, fileReportBasename);
 
                         if (covered > total) {
                             throw Error(
                                 `Got ${covered} covered lines for a` +
-                                    ` total of ${total} in ${file['@_name']!}`,
+                                    ` total of ${total} in ${file['@_name']}`,
                             );
                         }
 

Diff for: integration/vscode/ada/src/helpers.ts

@@ -644,3 +644,71 @@ export function staggerProgress(
 export function slugify(arg: string): string {
     return arg.replace(/[<>:"/\\|?*]/g, '_');
 }
+/**
+ * @returns the length of the common suffix between the given strings. If there
+ * is no common suffix, the result is `0`.
+ */
+export function getLengthCommonSuffix(str1: string, str2: string): number {
+    /**
+     * Compare characters from the end of each string and iterating backwards.
+     */
+    let len = 0;
+    while (
+        len < str1.length &&
+        len < str2.length &&
+        str1[str1.length - 1 - len] == str2[str2.length - 1 - len]
+    ) {
+        len++;
+    }
+
+    return len;
+}
+
+/**
+ *
+ * @param p - a path
+ * @returns a POSIX version of the same path obtained by replacing occurences
+ * of `\` with `/`. If the input path was a Windows absolute path, a `/` is
+ * prepended to the output to make it also an absolute path.
+ */
+export function toPosix(p: string) {
+    let posixPath = p.replace(RegExp(`\\${path.win32.sep}`, 'g'), path.posix.sep);
+
+    /**
+     * If it was an absolute path from Windows, we have to
+     * manually make it a POSIX absolute path.
+     */
+    if (path.win32.isAbsolute(p) && !path.posix.isAbsolute(posixPath)) {
+        posixPath = `/${posixPath}`;
+    }
+
+    return posixPath;
+}
+
+/**
+ *
+ * @param path1 - a path
+ * @param path2 - another path
+ * @returns if the given paths end with a common suffix, the remaining prefixes
+ * are returned as a tuple by this function. Otherwise, undefined prefixes are
+ * returned.
+ */
+export function getMatchingPrefixes(
+    path1: string,
+    path2: string,
+): [string | undefined, string | undefined] {
+    const lenCommonSuffix = getLengthCommonSuffix(path1, path2);
+
+    let prefix1;
+    let prefix2;
+
+    if (lenCommonSuffix > 0) {
+        prefix1 = path1.slice(0, path1.length - lenCommonSuffix);
+        prefix2 = path2.slice(0, path2.length - lenCommonSuffix);
+    } else {
+        // Could not find a common suffix
+        prefix1 = prefix2 = undefined;
+    }
+
+    return [prefix1, prefix2];
+}

Diff for: integration/vscode/ada/test/general/helpers.test.ts

@@ -2,10 +2,13 @@ import assert from 'assert';
 import {
     envHasExec,
     findAdaMain,
+    getLengthCommonSuffix,
+    getMatchingPrefixes,
     getSymbols,
     parallelize,
     slugify,
     staggerProgress,
+    toPosix,
     which,
 } from '../../src/helpers';
 import {
@@ -350,3 +353,63 @@ suite('staggerProgress', function () {
         assert.equal(slugify('file<>:"/\\|?*name'), 'file' + '_'.repeat(9) + 'name');
     });
 });
+
+suite('getLengthCommonSuffix', function () {
+    test('empty', function () {
+        assert.equal(getLengthCommonSuffix('', ''), 0);
+    });
+
+    test('one char', function () {
+        assert.equal(getLengthCommonSuffix('a', ''), 0);
+        assert.equal(getLengthCommonSuffix('', 'b'), 0);
+        assert.equal(getLengthCommonSuffix('a', 'a'), 1);
+        assert.equal(getLengthCommonSuffix('a', 'b'), 0);
+    });
+    test('two char', function () {
+        assert.equal(getLengthCommonSuffix('ab', ''), 0);
+        assert.equal(getLengthCommonSuffix('', 'ab'), 0);
+        assert.equal(getLengthCommonSuffix('ab', 'a'), 0);
+        assert.equal(getLengthCommonSuffix('ab', 'b'), 1);
+        assert.equal(getLengthCommonSuffix('ab', 'ab'), 2);
+        assert.equal(getLengthCommonSuffix('ab', 'cd'), 0);
+    });
+    test('more', function () {
+        assert.equal(getLengthCommonSuffix('abcdefg', ''), 0);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'g'), 1);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'x'), 0);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'fg'), 2);
+        assert.equal(getLengthCommonSuffix('abcdefg', 'abcdefg'), 7);
+    });
+});
+
+suite('toPosix', function () {
+    test('Windows paths', function () {
+        assert.equal(toPosix('C:\\some\\path'), '/C:/some/path');
+        assert.equal(toPosix('C:\\some\\path\\'), '/C:/some/path/');
+        assert.equal(toPosix(''), '');
+        assert.equal(toPosix('C:\\'), '/C:/');
+        assert.equal(toPosix('c:\\'), '/c:/');
+        assert.equal(toPosix('a\\relative\\path'), 'a/relative/path');
+    });
+    test('POSIX paths', function () {
+        assert.equal(toPosix('/'), '/');
+        assert.equal(toPosix('/some/path'), '/some/path');
+        assert.equal(toPosix('/some/path/'), '/some/path/');
+        assert.equal(toPosix('a/relative/path'), 'a/relative/path');
+    });
+});
+
+suite('getMatchingPrefixes', function () {
+    test('cases', function () {
+        assert.deepStrictEqual(
+            getMatchingPrefixes('/C:/a/b/common/part.adb', '/other/path/common/part.adb'),
+            ['/C:/a/b', '/other/path'],
+        );
+        assert.deepStrictEqual(
+            getMatchingPrefixes('/C:/a/b/d/e', '/other/path/with/no/common/part'),
+            [undefined, undefined],
+        );
+        assert.deepStrictEqual(getMatchingPrefixes('', ''), [undefined, undefined]);
+        assert.deepStrictEqual(getMatchingPrefixes('a', 'a'), ['', '']);
+    });
+});