Merge branch 'topic/auto-reload' into 'master'

Display a popup when saving a loaded GPR file

See merge request eng/ide/ada_language_server!2177

Author: AnthonyLeonardoGracio

CHANGELOG.md

@@ -6,6 +6,7 @@ section below it for the last release. -->
 
 * Reload `e3-testsuite` tests automatically after configuration changes
 * Provide completion for tool switches (e.g., `Default_Switches`) in GPR files
+* Automatically reload the project when GPR files are saved
 
 ## 2026.0.202510141
 

integration/vscode/ada/src/commands.ts

@@ -13,6 +13,7 @@ import {
     CMD_BUILD_AND_RUN_GNATEMULATOR,
     CMD_BUILD_AND_RUN_MAIN,
     CMD_GPR_PROJECT_ARGS,
+    CMD_RELOAD_PROJECT,
     CMD_RESTART_LANG_SERVERS,
     CMD_OPEN_USERS_GUIDE,
     CMD_SHOW_ADA_LS_OUTPUT,
@@ -741,6 +742,51 @@ export async function checkSrcDirectories(atStartup = false, displayYesNoPopup =
     }
 }
 
+/**
+ * Display a popup asking the user if they want to reload the GPR project.
+ * The popup has four options:
+ * - "Yes": executes CMD_RELOAD_PROJECT
+ * - "Always": executes CMD_RELOAD_PROJECT and stores a preference to always reload without asking
+ * - "No": does nothing
+ * - "Never": does nothing and stores a preference to never ask again
+ */
+export async function autoReloadProject() {
+    const alwaysReloadKey = 'ada.autoReloadProject.alwaysReload';
+    const neverReloadKey = 'ada.autoReloadProject.neverReload';
+    const alwaysReload = adaExtState.context.workspaceState.get(alwaysReloadKey);
+    const neverReload = adaExtState.context.workspaceState.get(neverReloadKey);
+
+    // If the user previously clicked "Always", reload without asking
+    if (alwaysReload) {
+        await vscode.commands.executeCommand(CMD_RELOAD_PROJECT);
+        return;
+    }
+
+    // If the user previously clicked "Never", don't ask and don't reload
+    if (neverReload) {
+        return;
+    }
+
+    // Ask the user if they want to reload the project
+    const answer = await vscode.window.showInformationMessage(
+        'Do you want to reload the project after saving?',
+        'Yes',
+        'Always',
+        'No',
+        'Never',
+    );
+
+    if (answer === 'Yes') {
+        await vscode.commands.executeCommand(CMD_RELOAD_PROJECT);
+    } else if (answer === 'Always') {
+        await vscode.commands.executeCommand(CMD_RELOAD_PROJECT);
+        await adaExtState.context.workspaceState.update(alwaysReloadKey, true);
+    } else if (answer === 'Never') {
+        await adaExtState.context.workspaceState.update(neverReloadKey, true);
+    }
+    // If answer is 'No' or undefined (user dismissed the dialog), do nothing
+}
+
 /*
  * This is a command handler that builds and runs the main given as parameter.
  * If the given URI does not match one of the project Mains an error is

integration/vscode/ada/src/constants.ts

@@ -81,6 +81,12 @@ export const CMD_SHOW_GPR_LS_OUTPUT = 'ada.showGprLSOutput';
  */
 export const CMD_RELOAD_PROJECT = 'als-reload-project';
 
+/**
+ * Identifier for the command that retrieves the list of dependencies of the specified
+ * GPR project.
+ */
+export const CMD_GPR_PROJECT_DEPENDENCIES = 'als-gpr-dependencies';
+
 /**
  * Identifier for the command that restarts all the language servers spawned by the extension
  * (Ada and GPR).

integration/vscode/ada/src/extension.ts

@@ -24,10 +24,11 @@ import Transport from 'winston-transport';
 import { ExtensionState } from './ExtensionState';
 import { ALSClientFeatures } from './alsClientFeatures';
 import { alsCommandExecutor } from './alsExecuteCommand';
-import { registerCommands } from './commands';
+import { autoReloadProject, registerCommands } from './commands';
 import {
     TERMINAL_ENV_SETTING_NAME,
     assertSupportedEnvironments,
+    belongsToLoadedProject,
     getEvaluatedTerminalEnv,
     startedInDebugMode,
 } from './helpers';
@@ -167,6 +168,16 @@ async function activateExtension(context: vscode.ExtensionContext) {
         vscode.languages.onDidChangeDiagnostics(adaExtState.updateStatusBarItem),
     );
 
+    // Subscribe to the didSaveTextDocument event to reload the project when .gpr files
+    // that belong to the loaded project tree are saved
+    context.subscriptions.push(
+        vscode.workspace.onDidSaveTextDocument(async (document) => {
+            if (await belongsToLoadedProject(document, logger)) {
+                void autoReloadProject();
+            }
+        }),
+    );
+
     const alsMiddleware: Middleware = {
         executeCommand: alsCommandExecutor(adaExtState.adaClient),
     };

integration/vscode/ada/src/helpers.ts

@@ -24,6 +24,11 @@ import winston from 'winston';
 
 import { existsSync } from 'fs';
 import { EXTENSION_NAME, adaExtState, logger, mainOutputChannel } from './extension';
+import {
+    ALS_GprDependencyDirection,
+    ALS_GprDependencyItem,
+    ALS_GprDependencyParam,
+} from './visualizerTypes';
 
 /* Whether we are under Windows */
 const isWindows = process.platform === 'win32';
@@ -727,3 +732,54 @@ export function getMatchingPrefixes(
  * environment.
  */
 export const inTesting = process.env['ALS_VSCODE_TEST_ENV'] === '1';
+
+/**
+ * Check if a document is a .gpr file that belongs to the currently loaded project tree.
+ * Returns true if the document is either the root project file or part of its dependencies.
+ *
+ * @param document - the document to check
+ * @param logger - a logger instance to log errors
+ * @returns true if the document is a .gpr file that belongs to the loaded project tree
+ */
+export async function belongsToLoadedProject(
+    document: vscode.TextDocument,
+    logger: winston.Logger,
+): Promise<boolean> {
+    // Only check GPR files
+    if (document.languageId !== 'gpr') {
+        return false;
+    }
+
+    try {
+        // Get the currently loaded project file
+        const currentProjectFile = await adaExtState.getProjectFile();
+        const currentProjectUri = vscode.Uri.file(currentProjectFile);
+
+        // Check if the document is the current project file
+        if (document.uri.fsPath === currentProjectUri.fsPath) {
+            return true;
+        }
+
+        // Get the project dependencies
+        const dependencies = await vscode.commands.executeCommand<ALS_GprDependencyItem[]>(
+            'als-gpr-dependencies',
+            {
+                uri: currentProjectUri.toString(),
+                direction: ALS_GprDependencyDirection.SHOW_OUTGOING,
+            } as ALS_GprDependencyParam,
+        );
+
+        if (dependencies) {
+            // Check if the document is in the dependencies
+            return dependencies.some((dep) => {
+                const depUri = vscode.Uri.parse(dep.uri);
+                return depUri.fsPath === document.uri.fsPath;
+            });
+        }
+
+        return false;
+    } catch (error) {
+        logger.error('Failed to check if document belongs to loaded project: ' + String(error));
+        return false;
+    }
+}

integration/vscode/ada/test/general/extension.test.ts

@@ -213,6 +213,89 @@ suite('Extensions Test Suite', function () {
         }
     });
 
+    test('Auto Reload Project On Save', async () => {
+        if (vscode.workspace.workspaceFolders !== undefined) {
+            // Get the workspace root folder
+            const folder = vscode.workspace.workspaceFolders[0].uri;
+
+            // Set the 'Always' preference for auto-reload, just for this test
+            const alwaysReloadKey = 'ada.autoReloadProject.alwaysReload';
+            await adaExtState.context.workspaceState.update(alwaysReloadKey, true);
+
+            try {
+                // Check that Exec_Dir is not initially set (should be empty or default)
+                const initialExecDir = await adaExtState.getProjectAttributeValue('Exec_Dir');
+                assert.strictEqual(initialExecDir, 'obj', 'Exec_Dir should be initially "obj"');
+
+                // Open the GPR file
+                const fileUri = vscode.Uri.joinPath(folder, 'prj.gpr');
+                const document = await vscode.workspace.openTextDocument(fileUri);
+                const editor = await vscode.window.showTextDocument(document);
+
+                // Store the original content
+                const contentBefore = document.getText();
+
+                // Edit the document to add Exec_Dir attribute
+                const text = document.getText();
+                const modifiedText = text.replace(
+                    '    for Object_Dir use "obj";',
+                    '    for Object_Dir use "obj";\n    for Exec_Dir use "bin";',
+                );
+
+                await editor.edit((editBuilder) => {
+                    const fullRange = new vscode.Range(
+                        document.positionAt(0),
+                        document.positionAt(text.length),
+                    );
+                    editBuilder.replace(fullRange, modifiedText);
+                });
+
+                // Save the document to trigger the auto-reload
+                await document.save();
+
+                // Wait a bit for the auto-reload to complete
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+
+                // Check that Exec_Dir has been set to "bin"
+                const newExecDir = await adaExtState.getProjectAttributeValue('Exec_Dir');
+                assert.strictEqual(
+                    newExecDir,
+                    'bin',
+                    'Exec_Dir should be set to "bin" after auto-reload',
+                );
+
+                // Restore the original content using the VS Code API
+                const currentText = document.getText();
+                await editor.edit((editBuilder) => {
+                    const fullRange = new vscode.Range(
+                        document.positionAt(0),
+                        document.positionAt(currentText.length),
+                    );
+                    editBuilder.replace(fullRange, contentBefore);
+                });
+
+                // Save again to trigger another auto-reload
+                await document.save();
+
+                // Wait for the auto-reload
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+
+                // Check that Exec_Dir is back to its initial value
+                const restoredExecDir = await adaExtState.getProjectAttributeValue('Exec_Dir');
+                assert.strictEqual(
+                    restoredExecDir,
+                    initialExecDir,
+                    'Exec_Dir should be restored to its initial value',
+                );
+            } finally {
+                // Clear the 'Always' preference
+                await adaExtState.context.workspaceState.update(alwaysReloadKey, undefined);
+            }
+        } else {
+            throw new Error('No workspace folder found for the specified URI');
+        }
+    });
+
     test('Split long comments on ENTER', async () => {
         if (vscode.workspace.workspaceFolders !== undefined) {
             // Get a file with a long comment (>80 chars)