Merge branch 'topic/eng/ide/ada_language_server#1375' into 'master'

Add 'Build & Run with GNATemulator' task and CodeLens

See merge request eng/ide/ada_language_server!1912

Author: AnthonyLeonardoGracio

integration/vscode/ada/src/AdaCodeLensProvider.ts

@@ -11,8 +11,14 @@ import {
     commands,
     Uri,
 } from 'vscode';
-import { CMD_BUILD_AND_DEBUG_MAIN, CMD_BUILD_AND_RUN_MAIN, CMD_SPARK_PROVE_SUBP } from './commands';
-import { envHasExec, getMains, getSymbols } from './helpers';
+import {
+    CMD_BUILD_AND_DEBUG_MAIN,
+    CMD_BUILD_AND_RUN_GNATEMULATOR,
+    CMD_BUILD_AND_RUN_MAIN,
+    CMD_SPARK_PROVE_SUBP,
+} from './commands';
+import { envHasExec, getSymbols } from './helpers';
+import { adaExtState } from './extension';
 
 export class AdaCodeLensProvider implements CodeLensProvider {
     onDidChangeCodeLenses?: Event<void> | undefined;
@@ -28,46 +34,61 @@ export class AdaCodeLensProvider implements CodeLensProvider {
         /**
          * For main procedures, provide Run and Debug CodeLenses.
          */
-        const res1 = getMains().then((mains) => {
-            if (
-                mains.some(
-                    (m) =>
-                        // Here we go through the Uri class to benefit from the normalization
-                        // of path casing on Windows. See Uri.fsPath documentation.
-                        Uri.file(m).fsPath == document.uri.fsPath,
-                )
-            ) {
-                // It's a main file, so let's offer Run and Debug actions on the main subprogram
-                return symbols.then((symbols) => {
-                    const functions = symbols.filter((s) => s.kind == SymbolKind.Function);
-                    if (functions.length > 0) {
-                        /**
-                         * We choose to provide the CodeLenses on the first
-                         * subprogram of the file. It may be possible that the
-                         * main subprogram is not the first one, but that's an
-                         * unlikely scenario that we choose not to handle for
-                         * the moment.
-                         */
-                        return [
-                            new CodeLens(functions[0].range, {
-                                command: CMD_BUILD_AND_RUN_MAIN,
-                                title: '$(run) Run',
-                                arguments: [document.uri],
-                            }),
-                            // TODO implement this command
-                            new CodeLens(functions[0].range, {
-                                command: CMD_BUILD_AND_DEBUG_MAIN,
-                                title: '$(debug-alt-small) Debug',
-                                arguments: [document.uri],
-                            }),
-                        ];
-                    } else {
-                        return [];
-                    }
-                });
-            } else {
-                return [];
-            }
+        const res1 = adaExtState.getTargetPrefix().then((targetPrefix) => {
+            return adaExtState.getMains().then((mains) => {
+                if (
+                    mains.some(
+                        (m) =>
+                            // Here we go through the Uri class to benefit from the normalization
+                            // of path casing on Windows. See Uri.fsPath documentation.
+                            Uri.file(m).fsPath == document.uri.fsPath,
+                    )
+                ) {
+                    // It's a main file, so let's offer Run and Debug actions on the main subprogram
+                    return symbols.then((symbols) => {
+                        const functions = symbols.filter((s) => s.kind == SymbolKind.Function);
+                        if (functions.length > 0) {
+                            /**
+                             * We choose to provide the CodeLenses on the first
+                             * subprogram of the file. It may be possible that the
+                             * main subprogram is not the first one, but that's an
+                             * unlikely scenario that we choose not to handle for
+                             * the moment.
+                             */
+                            let codeLenses = [
+                                new CodeLens(functions[0].range, {
+                                    command: CMD_BUILD_AND_RUN_MAIN,
+                                    title: '$(run) Run',
+                                    arguments: [document.uri],
+                                }),
+                                new CodeLens(functions[0].range, {
+                                    command: CMD_BUILD_AND_DEBUG_MAIN,
+                                    title: '$(debug-alt-small) Debug',
+                                    arguments: [document.uri],
+                                }),
+                            ];
+
+                            // It's not a native project: provide a 'Run with GNATemulator' CodeLens
+                            // if GNATemulator for the given target is present in the user's env.
+                            if (targetPrefix && envHasExec(targetPrefix + '-gnatemu')) {
+                                codeLenses = codeLenses.concat([
+                                    new CodeLens(functions[0].range, {
+                                        command: CMD_BUILD_AND_RUN_GNATEMULATOR,
+                                        title: '$(run) Run with GNATemulator',
+                                        arguments: [document.uri],
+                                    }),
+                                ]);
+                            }
+
+                            return codeLenses;
+                        } else {
+                            return [];
+                        }
+                    });
+                } else {
+                    return [];
+                }
+            });
         });
 
         let res2;

integration/vscode/ada/src/ExtensionState.ts

@@ -311,6 +311,17 @@ export class ExtensionState {
         return this.cachedProjectUri;
     }
 
+    /**
+     * Returns true if the loaded project is a native project, false if
+     * it's a cross/bare-metal one.
+     *
+     * @returns a boolean indicating if the loaded project is a native one.
+     */
+    public async isNativeProject(): Promise<boolean> {
+        const targetPrefix = await this.getTargetPrefix();
+        return targetPrefix == '' || targetPrefix === undefined;
+    }
+
     /**
      * Returns the target prefix that should be used when spawning tools
      * like gnat, gcc or gdb.
@@ -321,16 +332,29 @@ export class ExtensionState {
      * @returns the target prefix
      */
     public async getTargetPrefix(): Promise<string> {
-        if (!this.cachedTargetPrefix) {
+        if (this.cachedTargetPrefix === undefined) {
             // Get the compiler driver's path from the Compiler.Driver project
-            // attribute, and delete the last bit to get the prefix
-            const driverPath = (await this.getProjectAttributeValue(
-                'driver',
-                'compiler',
-                'ada',
-            )) as string;
-            const driver = path.basename(driverPath);
-            this.cachedTargetPrefix = driver.substring(0, driver.lastIndexOf('-'));
+            // attribute, and delete the last bit to get the prefix.
+            // We get an exception when the attribute is not defined, which can
+            // happen when there is no available toolchain for the project's target:
+            // in that case, consider the project as a native one.
+            try {
+                const driverPath = (await this.getProjectAttributeValue(
+                    'driver',
+                    'compiler',
+                    'ada',
+                )) as string;
+                logger.info(`Got Project.Compiler.Driver ("ada") = ${driverPath}`);
+                const driver = path.basename(driverPath);
+                this.cachedTargetPrefix = driver.substring(0, driver.lastIndexOf('-'));
+                logger.info(`Computed target prefix: ${this.cachedTargetPrefix}`);
+            } catch (err) {
+                const errMessage =
+                    err instanceof Error ? err.message : typeof err === 'string' ? err : '';
+                logger.warn(`Failed to get Project.Compiler.Driver ("ada"): ${errMessage}`);
+                logger.warn('Assuming empty target prefix');
+                this.cachedTargetPrefix = '';
+            }
         }
 
         return this.cachedTargetPrefix;

integration/vscode/ada/src/commands.ts

@@ -18,10 +18,11 @@ import {
     TASK_PROVE_SUPB_PLAIN_NAME,
     TASK_TYPE_SPARK,
     findBuildAndRunTask,
-    getBuildAndRunTasks,
+    getTasksWithPrefix,
     getConventionalTaskLabel,
     isFromWorkspace,
     workspaceTasksFirst,
+    getBuildAndRunTaskName,
 } from './taskProviders';
 import { createHelloWorldProject, walkthroughStartDebugging } from './walkthrough';
 
@@ -43,6 +44,16 @@ export const CMD_BUILD_AND_RUN_MAIN = 'ada.buildAndRunMain';
  */
 export const CMD_BUILD_AND_DEBUG_MAIN = 'ada.buildAndDebugMain';
 
+/**
+ * Identifier for a hidden command used for building and running a project main,
+ * using GNATemulator.
+ * The command accepts a parameter which is the URI of the main source file.
+ * It is triggered by CodeLenses provided by the extension.
+ *
+ * @see {@link buildAndRunMainWithGNATemulator}
+ */
+export const CMD_BUILD_AND_RUN_GNATEMULATOR = 'ada.buildAndRunGNATemulator';
+
 /**
  * Identifier for a hidden command that returns an array of strings constituting
  * the -P and -X project and scenario arguments.
@@ -127,6 +138,12 @@ export function registerCommands(context: vscode.ExtensionContext, clients: Exte
     context.subscriptions.push(
         vscode.commands.registerCommand(CMD_BUILD_AND_DEBUG_MAIN, buildAndDebugSpecifiedMain),
     );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(
+            CMD_BUILD_AND_RUN_GNATEMULATOR,
+            buildAndRunMainWithGNATemulator,
+        ),
+    );
 
     context.subscriptions.push(
         vscode.commands.registerCommand(CMD_GPR_PROJECT_ARGS, gprProjectArgs),
@@ -241,7 +258,7 @@ let lastUsedTaskInfo: { source: string; name: string } | undefined;
  * @returns the TaskExecution corresponding to the task.
  */
 async function buildAndRunMainLast() {
-    const buildAndRunTasks = await getBuildAndRunTasks();
+    const buildAndRunTasks = await getTasksWithPrefix(getBuildAndRunTaskName());
     if (lastUsedTaskInfo) {
         const matchingTasks = buildAndRunTasks.filter(matchesLastUsedTask);
         assert(matchingTasks.length <= 1);
@@ -305,7 +322,7 @@ async function buildAndRunMainAsk() {
             ],
         };
     }
-    const adaTasksMain = await getBuildAndRunTasks();
+    const adaTasksMain = await getTasksWithPrefix(getBuildAndRunTaskName());
 
     if (adaTasksMain.length > 0) {
         const tasksFromWorkspace = adaTasksMain.filter(isFromWorkspace);
@@ -555,17 +572,23 @@ export async function checkSrcDirectories(atStartup = false, displayYesNoPopup =
  * displayed.
  *
  * @param main - a URI of a document
+ * @param useGNATemulator - whether the main should be ran through
+ * GNATemulator.
  */
-async function buildAndRunSpecifiedMain(main: vscode.Uri): Promise<void> {
+async function buildAndRunSpecifiedMain(
+    main: vscode.Uri,
+    useGNATemulator: boolean = false,
+): Promise<void> {
     const adaMain = await findAdaMain(main.fsPath);
     if (adaMain) {
-        const task = await findBuildAndRunTask(adaMain);
+        const task = await findBuildAndRunTask(adaMain, useGNATemulator);
         if (task) {
             lastUsedTaskInfo = { source: task.source, name: task.name };
             await vscode.tasks.executeTask(task);
         } else {
+            const taskLabel = useGNATemulator ? 'Build and Run GNATemulator' : 'Build and Run';
             void vscode.window.showErrorMessage(
-                `Could not find the 'Build and Run' task for the project main ` +
+                `Could not find the '${taskLabel}' task for the project main ` +
                     `${adaMain.mainRelPath()}`,
                 { modal: true },
             );
@@ -579,6 +602,18 @@ async function buildAndRunSpecifiedMain(main: vscode.Uri): Promise<void> {
     }
 }
 
+/*
+ * This is a command handler that builds and runs the main given as parameter,
+ * using GNATemulator to run the executable.
+ * If the given URI does not match one of the project Mains an error is
+ * displayed.
+ *
+ * @param main - a URI of a document
+ */
+async function buildAndRunMainWithGNATemulator(main: vscode.Uri): Promise<void> {
+    return buildAndRunSpecifiedMain(main, true);
+}
+
 /**
  * This is a command handler that builds the main given as parameter and starts
  * a debug session on that main.  If the given URI does not match one of the