Warn when starting debugging with no Mains available

eliericha · eliericha · commit 3f3facd00939 · 2023-09-11T11:48:12.000Z
diff --git a/integration/vscode/ada/src/debugConfigProvider.ts b/integration/vscode/ada/src/debugConfigProvider.ts
@@ -1,9 +1,8 @@
+import assert from 'assert';
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { ContextClients } from './clients';
-import { getExecutables, getMains } from './helpers';
-import assert from 'assert';
-import { exec } from 'child_process';
+import { contextClients } from './extension';
+import { getExecutables, getMains, getProjectFile } from './helpers';
 
 /**
  * Ada Configuration for a debug session
@@ -23,14 +22,14 @@ interface AdaConfig extends vscode.DebugConfiguration {
 }
 
 /**
- * Initialize debugging on an ada project by creating a default configuration in launch.json
- * @param ctx - the ada extension context
- * @param clients - the language clients
+ * Initialize debugging support for Ada projects.
+ *
+ * @param ctx - the Ada extension context
  * @returns the debug configuration provider
  */
-export function initializeDebugging(ctx: vscode.ExtensionContext, clients: ContextClients) {
+export function initializeDebugging(ctx: vscode.ExtensionContext) {
     // Instantiate a DebugConfigProvider for Ada and register it.
-    const provider = new AdaDebugConfigProvider(clients);
+    const provider = new AdaDebugConfigProvider();
 
     // This provider is registered for the 'ada' debugger type. It means that
     // it is triggered either when a configuration with type 'ada' is launched,
@@ -55,7 +54,8 @@ export function initializeDebugging(ctx: vscode.ExtensionContext, clients: Conte
 /**
  * Initialize a debug configuration based on 'cppdbg' for the given executable
  * if specified. Otherwise the program field includes
- * ${command:ada.getOrAskForProgram} to prompt the User for an executable to debug.
+ * $\{command:ada.getOrAskForProgram\} to prompt the User for an executable to
+ * debug.
  *
  * @param program - the executable to debug (optional)
  * @returns an AdaConfig
@@ -88,13 +88,8 @@ function initializeConfig(program?: string): AdaConfig {
 }
 
 export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider {
-    private readonly clients: ContextClients;
     public static adaConfigType = 'cppdbg';
 
-    constructor(clients: ContextClients) {
-        this.clients = clients;
-    }
-
     async provideDebugConfigurations(
         folder: vscode.WorkspaceFolder | undefined,
         _token?: vscode.CancellationToken | undefined
@@ -110,36 +105,42 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
 
         if (folder != undefined) {
             // Offer a list of known Mains from the project
-            const mains = await getMains(this.clients.adaClient);
-            const execs = await getExecutables(this.clients.adaClient);
+            const mains = await getMains(contextClients.adaClient);
+            const execs = await getExecutables(contextClients.adaClient);
             assert(
                 execs.length == mains.length,
                 `The ALS returned mains.length = ${mains.length} and ` +
                     `execs.length = ${execs.length}` +
                     `when they should be equal`
             );
-            const quickpick = [];
-            for (let i = 0; i < mains.length; i++) {
-                const exec = execs[i];
-                const main = mains[i];
-                quickpick.push({
-                    label: vscode.workspace.asRelativePath(main),
-                    description: 'Generate the associated launch configuration',
-                    execPath: vscode.workspace.asRelativePath(exec),
+
+            if (mains.length > 0) {
+                const quickpick = [];
+                for (let i = 0; i < mains.length; i++) {
+                    const exec = execs[i];
+                    const main = mains[i];
+                    quickpick.push({
+                        label: vscode.workspace.asRelativePath(main),
+                        description: 'Generate the associated launch configuration',
+                        execPath: vscode.workspace.asRelativePath(exec),
+                    });
+                }
+                const selectedProgram = await vscode.window.showQuickPick(quickpick, {
+                    placeHolder: 'Select a main to create a launch configuration',
                 });
-            }
-            const selectedProgram = await vscode.window.showQuickPick(quickpick, {
-                placeHolder: 'Select a main to create a launch configuration',
-            });
-            if (selectedProgram) {
-                // The cppdbg debug configuration exepects the executable to be
-                // a full path rather than a path relative to the specified
-                // cwd. That is why we include ${workspaceFolder}.
-                const configuration = initializeConfig(
-                    `\${workspaceFolder}/${selectedProgram.execPath}`
-                );
-                configs.push(configuration);
+                if (selectedProgram) {
+                    // The cppdbg debug configuration exepects the executable to be
+                    // a full path rather than a path relative to the specified
+                    // cwd. That is why we include ${workspaceFolder}.
+                    const configuration = initializeConfig(
+                        `\${workspaceFolder}/${selectedProgram.execPath}`
+                    );
+                    configs.push(configuration);
+                } else {
+                    return Promise.reject('Cancelled');
+                }
             } else {
+                void warnAboutNoMains();
                 return Promise.reject('Cancelled');
             }
         }
@@ -171,56 +172,79 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
             return debugConfiguration;
         }
 
-        const exec = await this.getOrAskForProgram();
+        const exec = await getOrAskForProgram();
 
         if (exec) {
             return initializeConfig(`\${workspaceFolder}/${exec}`);
         }
 
         return undefined;
     }
+}
 
-    /**
-     * Get an executable based on the project and the current open file.
-     *
-     * If the project only defines one main, it is returned immediately.
-     *
-     * If the project defines multiple mains, and if the current open file
-     * matches one of the mains, the corresponding executable is returned.
-     *
-     * Otherwise, the list of mains is offered to the user as a QuickPicker to
-     * choose a main file. The executable corresponding to the selected main
-     * file is returned.
-     *
-     * Note that paths are returned relative to the workspace.
-     *
-     * @returns the path of the executable to debug *relative to the workspace*,
-     * or *undefined* if no selection was made.
-     */
-    async getOrAskForProgram(): Promise<string | undefined> {
-        const mains = await getMains(this.clients.adaClient);
-        const execs = await getExecutables(this.clients.adaClient);
+/**
+ * GDB default setup options
+ */
+const setupCmd = [
+    {
+        description: 'Catch all Ada exceptions',
+        text: 'catch exception',
+        ignoreFailures: true,
+    },
+    {
+        description: 'Enable pretty-printing for gdb',
+        text: '-enable-pretty-printing',
+        ignoreFailures: true,
+    },
+    {
+        description: 'Set Disassembly Flavor to Intel',
+        text: '-gdb-set disassembly-flavor intel',
+        ignoreFailures: true,
+    },
+];
 
-        assert(
-            execs.length == mains.length,
-            `The ALS returned mains.length = ${mains.length} and ` +
-                `execs.length = ${execs.length}` +
-                `when they should be equal`
-        );
+/**
+ * Get an executable based on the project and the current open file.
+ *
+ * If the project only defines one main, it is returned immediately.
+ *
+ * If the project defines multiple mains, and if the current open file
+ * matches one of the mains, the corresponding executable is returned.
+ *
+ * Otherwise, the list of mains is offered to the user as a QuickPicker to
+ * choose a main file. The executable corresponding to the selected main
+ * file is returned.
+ *
+ * Note that paths are returned relative to the workspace.
+ *
+ * @returns the path of the executable to debug *relative to the workspace*,
+ * or *undefined* if no selection was made.
+ */
+async function getOrAskForProgram(): Promise<string | undefined> {
+    const mains = await getMains(contextClients.adaClient);
+    const execs = await getExecutables(contextClients.adaClient);
 
-        if (execs.length == 1) return vscode.workspace.asRelativePath(execs[0]);
+    assert(
+        execs.length == mains.length,
+        `The ALS returned mains.length = ${mains.length} and ` +
+            `execs.length = ${execs.length}` +
+            `when they should be equal`
+    );
 
-        // Check if the current file matches one of the mains of the project. If
-        // so, use it.
-        const file = vscode.window.activeTextEditor?.document.uri.path;
-        if (file != undefined) {
-            for (let i = 0; i < mains.length; i++) {
-                if (file == mains[i]) {
-                    return vscode.workspace.asRelativePath(execs[i]);
-                }
+    if (execs.length == 1) return vscode.workspace.asRelativePath(execs[0]);
+
+    // Check if the current file matches one of the mains of the project. If
+    // so, use it.
+    const file = vscode.window.activeTextEditor?.document.uri.path;
+    if (file != undefined) {
+        for (let i = 0; i < mains.length; i++) {
+            if (file == mains[i]) {
+                return vscode.workspace.asRelativePath(execs[i]);
             }
         }
+    }
 
+    if (mains.length > 0) {
         // There is no current file or it matches no known Main of the project,
         // so we offer all Mains in a QuickPicker for the user to choose from.
         const quickpick = [];
@@ -239,28 +263,16 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
         if (selectedProgram) {
             return selectedProgram.execRelPath;
         }
-
-        return undefined;
+    } else {
+        void warnAboutNoMains();
     }
-}
 
-/**
- * GDB default setup options
- */
-const setupCmd = [
-    {
-        description: 'Catch all Ada exceptions',
-        text: 'catch exception',
-        ignoreFailures: true,
-    },
-    {
-        description: 'Enable pretty-printing for gdb',
-        text: '-enable-pretty-printing',
-        ignoreFailures: true,
-    },
-    {
-        description: 'Set Disassembly Flavor to Intel',
-        text: '-gdb-set disassembly-flavor intel',
-        ignoreFailures: true,
-    },
-];
+    return undefined;
+}
+async function warnAboutNoMains() {
+    void vscode.window.showWarningMessage(
+        `Your Ada project file '${await getProjectFile(
+            contextClients.adaClient
+        )}' does not define a 'Main' attribute. ` + 'Debugging is not possible without it.'
+    );
+}
diff --git a/integration/vscode/ada/src/extension.ts b/integration/vscode/ada/src/extension.ts
@@ -78,7 +78,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
 
     await Promise.all([contextClients.adaClient.onReady(), contextClients.gprClient.onReady()]);
 
-    const adaDebugConfigProvider = initializeDebugging(context, contextClients);
+    const adaDebugConfigProvider = initializeDebugging(context);
 
     registerCommands(context, contextClients, adaDebugConfigProvider);
 
diff --git a/integration/vscode/ada/src/helpers.ts b/integration/vscode/ada/src/helpers.ts
@@ -198,14 +198,18 @@ type ExecutablesResponse = {
 };
 
 /**
- * Get the project file from the configuration or if not, the language server
+ * Get the project file from the workspace configuration if available, or from
+ * the ALS if not.
+ *
  * @param client - the client to send the request to
  * @returns a string contains the path of the project file
  */
 export async function getProjectFile(client: LanguageClient): Promise<string> {
-    const config: string | undefined = vscode.workspace.getConfiguration('ada').get('projectFile');
-    if (config != undefined && config != '') {
-        return config;
+    const configValue: string | undefined = vscode.workspace
+        .getConfiguration('ada')
+        .get('projectFile');
+    if (configValue != undefined && configValue != '') {
+        return configValue;
     } else {
         const result: ProjectFileResponse = await client.sendRequest('$/glsProjectFile');
         return result.projectFile;
