Updates to vscode debug launch configurations

eliericha · eliericha · commit 2253f748639b · 2024-01-16T16:14:37.000Z
* Create a launch configuration for each main for attaching to a running
  process
* Make debug configurations have preLaunchTask fields pointing to build
  tasks
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
@@ -7,6 +7,7 @@
       "dbaeumer.vscode-eslint",
       "esbenp.prettier-vscode",
       "gruntfuggly.triggertaskonsave",
-      "davidanson.vscode-markdownlint"
+      "davidanson.vscode-markdownlint",
+      "adacore.ada"
    ]
 }
diff --git a/integration/vscode/ada/src/commands.ts b/integration/vscode/ada/src/commands.ts
@@ -39,10 +39,12 @@ export function registerCommands(context: vscode.ExtensionContext, clients: Exte
 
     // This is a hidden command that gets called in the default debug
     // configuration snippet that gets offered in the launch.json file.
+    // It is expected to return the relative path of the main program chosen for
+    // debugging.
     context.subscriptions.push(
         vscode.commands.registerCommand('ada.getOrAskForProgram', async () => {
             const p = await getOrAskForProgram();
-            return p;
+            return p?.execRelPath();
         })
     );
 
diff --git a/integration/vscode/ada/src/debugConfigProvider.ts b/integration/vscode/ada/src/debugConfigProvider.ts
@@ -2,22 +2,24 @@ import assert from 'assert';
 import * as vscode from 'vscode';
 import { adaExtState } from './extension';
 import { AdaMain, getAdaMains, getProjectFile } from './helpers';
+import { BUILD_PROJECT_TASK_NAME, getBuildTaskName } from './taskProviders';
 
 /**
  * Ada Configuration for a debug session
  */
 interface AdaConfig extends vscode.DebugConfiguration {
     MIMode: string;
     program: string;
-    cwd: string;
-    targetArchitecture: string;
-    stopAtEntry: boolean;
-    args: string[];
-    setupCommands: {
+    cwd?: string;
+    targetArchitecture?: string;
+    stopAtEntry?: boolean;
+    args?: string[];
+    setupCommands?: {
         description: string;
         text: string;
         ignoreFailures: boolean;
     }[];
+    processId?: string;
 }
 
 /**
@@ -53,9 +55,9 @@ export function initializeDebugging(ctx: vscode.ExtensionContext) {
                 ): Promise<vscode.DebugConfiguration[]> {
                     const quickpick = await createQuickPickItems('Build & Debug');
 
-                    const configs: vscode.DebugConfiguration[] = quickpick.map((i) => {
+                    const configs: AdaConfig[] = quickpick.flatMap((i) => {
                         assert(i.adaMain);
-                        return initializeConfig(i.adaMain.execFullPath, i.adaMain.mainRelPath());
+                        return [initializeConfig(i.adaMain), createAttachConfig(i.adaMain)];
                     });
 
                     return configs;
@@ -89,27 +91,23 @@ export function initializeDebugging(ctx: vscode.ExtensionContext) {
  * 'program' parameter.
  * @returns an AdaConfig
  */
-function initializeConfig(program?: string, main?: string, name?: string): AdaConfig {
+function initializeConfig(main: AdaMain, name?: string): AdaConfig {
     // TODO it would be nice if this and the package.json configuration snippet
     // were the same.
     const config: AdaConfig = {
         type: 'cppdbg',
-        name:
-            name ??
-            (main
-                ? `Ada: Debug main - ${main}`
-                : program
-                ? `Ada: Debug executable - ${program.replace('${workspaceFolder}/', '')}`
-                : 'Ada: Debugger Launch'),
+        name: name ?? (main ? `Ada: Debug main - ${main.mainRelPath()}` : 'Ada: Debugger Launch'),
         request: 'launch',
         targetArchitecture: process.arch,
         cwd: '${workspaceFolder}',
-        program: program ?? '${workspaceFolder}/${command:ada.getOrAskForProgram}',
+        program: main
+            ? `\${workspaceFolder}/${main.execRelPath()}`
+            : '${workspaceFolder}/${command:ada.getOrAskForProgram}',
         stopAtEntry: false,
         externalConsole: false,
         args: [],
         MIMode: 'gdb',
-        preLaunchTask: 'ada: Build current project',
+        preLaunchTask: main ? getBuildTaskName(main) : BUILD_PROJECT_TASK_NAME,
         setupCommands: setupCmd,
     };
 
@@ -155,12 +153,7 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
                     const item = quickpick[i];
                     if (item != generateAll) {
                         assert(item.adaMain);
-                        configs.push(
-                            initializeConfig(
-                                `\${workspaceFolder}/${item.adaMain.execRelPath()}`,
-                                item.adaMain.mainRelPath()
-                            )
-                        );
+                        configs.push(initializeConfig(item.adaMain));
                     }
                 }
             } else if (selectedProgram) {
@@ -169,10 +162,7 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
                 // 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.adaMain.execRelPath()}`,
-                    selectedProgram.label
-                );
+                const configuration = initializeConfig(selectedProgram.adaMain);
                 configs.push(configuration);
             } else {
                 return Promise.reject('Cancelled');
@@ -212,10 +202,10 @@ export class AdaDebugConfigProvider implements vscode.DebugConfigurationProvider
             // configuration on the fly.
             return debugConfiguration;
         } else {
-            const exec = await getOrAskForProgram();
+            const main = await getOrAskForProgram();
 
-            if (exec) {
-                return initializeConfig(`\${workspaceFolder}/${exec}`);
+            if (main) {
+                return initializeConfig(main);
             }
         }
 
@@ -308,31 +298,29 @@ async function assertProjectHasMains(mains?: AdaMain[]) {
  * 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.
+ * choose a main file. The object corresponding to the selected main file is
+ * returned.
  *
  * @param mains - a list of AdaMains if available at the caller site, otherwise
  * it is computed by the call.
- * @returns the path of the executable to debug *relative to the workspace*,
- * or *undefined* if no selection was made.
+ * @returns the object representing the selected main, or *undefined* if no
+ * selection was made.
  */
-export async function getOrAskForProgram(mains?: AdaMain[]): Promise<string | undefined> {
+export async function getOrAskForProgram(mains?: AdaMain[]): Promise<AdaMain | undefined> {
     // Compute list of mains if not provided by the caller
     mains = mains ?? (await getAdaMains());
 
     await assertProjectHasMains(mains);
 
-    if (mains.length == 1) return mains[0].execRelPath();
+    if (mains.length == 1) return mains[0];
 
     // Check if the current file matches one of the mains of the project. If
     // so, use it.
     const currentFile = vscode.window.activeTextEditor?.document.uri.path;
     if (currentFile != undefined) {
         const adaMain = await getAdaMainForSourceFile(currentFile, mains);
         if (adaMain) {
-            return adaMain.execRelPath();
+            return adaMain;
         }
     }
 
@@ -343,7 +331,7 @@ export async function getOrAskForProgram(mains?: AdaMain[]): Promise<string | un
         placeHolder: 'Select a main file to debug',
     });
     if (selectedProgram) {
-        return selectedProgram.adaMain?.execRelPath();
+        return selectedProgram.adaMain;
     }
 
     return undefined;
@@ -366,3 +354,15 @@ async function getAdaMainForSourceFile(
 
     return mains.find((val) => srcPath == val.mainFullPath);
 }
+
+function createAttachConfig(adaMain: AdaMain): AdaConfig {
+    return {
+        name: `Ada: Attach debugger to running process - ${adaMain.mainRelPath()}`,
+        type: 'cppdbg',
+        request: 'attach',
+        program: `\${workspaceFolder}/${adaMain.execRelPath()}`,
+        processId: '${command:pickProcess}',
+        MIMode: 'gdb',
+        preLaunchTask: adaMain ? getBuildTaskName(adaMain) : BUILD_PROJECT_TASK_NAME,
+    };
+}
diff --git a/integration/vscode/ada/src/taskProviders.ts b/integration/vscode/ada/src/taskProviders.ts
@@ -21,8 +21,9 @@ import { basename } from 'path';
 import * as vscode from 'vscode';
 import { SymbolKind } from 'vscode';
 import { adaExtState } from './extension';
-import { getAdaMains, getProjectFile } from './helpers';
-import { task } from 'fp-ts';
+import { AdaMain, getAdaMains, getProjectFile } from './helpers';
+
+export const ADA_TASK_TYPE = 'ada';
 
 /**
  * Callback to provide an extra argument for a tool
@@ -215,6 +216,9 @@ export const allTaskProperties: { [id in AllTaskKinds]: TaskProperties } = {
     },
 };
 
+// eslint-disable-next-line max-len
+export const BUILD_PROJECT_TASK_NAME = `${ADA_TASK_TYPE}: ${allTaskProperties['buildProject'].title}`;
+
 export const PROJECT_FROM_CONFIG = '${config:ada.projectFile}';
 async function getProjectFromConfigOrALS(): Promise<string> {
     return vscode.workspace.getConfiguration('ada').get('projectFile')
@@ -424,9 +428,7 @@ export class ConfigurableTaskProvider implements vscode.TaskProvider {
                                 main: main.mainRelPath(),
                             },
                         };
-                        const name = `${allTaskProperties['buildMain'].title}${basename(
-                            main.mainRelPath()
-                        )}`;
+                        const name = getBuildTaskPlainName(main);
                         const cmdLine = await buildFullCommandLine(name, def);
                         this.tasks?.push(
                             new vscode.Task(
@@ -448,6 +450,7 @@ export class ConfigurableTaskProvider implements vscode.TaskProvider {
                                 projectFile: await computeProject(),
                                 main: main.mainRelPath(),
                             },
+                            // dependsOn: getBuildTaskName(main),
                         };
                         const name = `${allTaskProperties['buildAndRunMain'].title}${basename(
                             main.mainRelPath()
@@ -512,6 +515,20 @@ export class ConfigurableTaskProvider implements vscode.TaskProvider {
     }
 }
 
+/**
+ * The name of the build task of a main, without the task type.
+ */
+function getBuildTaskPlainName(main: AdaMain) {
+    return `${allTaskProperties['buildMain'].title}${main.mainRelPath()}`;
+}
+
+/**
+ * The full name of the build task of a main, including the task type.
+ */
+export function getBuildTaskName(main: AdaMain) {
+    return `ada: ${getBuildTaskPlainName(main)}`;
+}
+
 export function createSparkTaskProvider(): ConfigurableTaskProvider {
     return new ConfigurableTaskProvider(
         'spark',

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`"dbaeumer.vscode-eslint",`
`8`	`8`	`"esbenp.prettier-vscode",`
`9`	`9`	`"gruntfuggly.triggertaskonsave",`
`10`		`- "davidanson.vscode-markdownlint"`
	`10`	`+ "davidanson.vscode-markdownlint",`
	`11`	`+ "adacore.ada"`
`11`	`12`	`]`
`12`	`13`	`}`