Merge branch 'topic/debug-attach' into 'master'

Improve vscode tasks and launch configurations

Closes #1265

See merge request eng/ide/ada_language_server!1478

Author: eliericha

.vscode/extensions.json

@@ -7,6 +7,7 @@
       "dbaeumer.vscode-eslint",
       "esbenp.prettier-vscode",
       "gruntfuggly.triggertaskonsave",
-      "davidanson.vscode-markdownlint"
+      "davidanson.vscode-markdownlint",
+      "adacore.ada"
    ]
 }

.vscode/tasks.json

@@ -46,10 +46,6 @@
          }
       },
       {
-         // This task starts a background npm process that monitors changes to
-         // TS files and recompiles them as needed. It is configured to be run
-         // before the (vscode)-based launch configurations to make sure the TS
-         // files are compiled and re-compiled upon changes.
          "type": "npm",
          "script": "watch",
          "path": "integration/vscode/ada",
@@ -68,6 +64,24 @@
          "problemMatcher": ["$ada"],
          "group": "build",
          "label": "ada: Check current file"
+      },
+      {
+         "type": "npm",
+         "script": "watch",
+         "path": "integration/vscode/ada",
+         "group": "build",
+         "problemMatcher": [
+            {
+               "base": "$tsc-watch",
+               "fileLocation": [
+                  "relative",
+                  "${workspaceFolder}/integration/vscode/ada"
+               ]
+            }
+         ],
+         "label": "npm: watch - integration/vscode/ada",
+         "detail": "node ./node_modules/typescript/bin/tsc -watch",
+         "isBackground": true
       }
    ]
 }

integration/vscode/ada/package.json

@@ -482,8 +482,7 @@
                     "configuration": {
                         "type": "object",
                         "required": [
-                            "kind",
-                            "projectFile"
+                            "kind"
                         ],
                         "properties": {
                             "kind": {
@@ -494,7 +493,16 @@
                                     "checkFile",
                                     "cleanProject",
                                     "buildMain",
+                                    "runMain",
                                     "buildAndRunMain"
+                                ],
+                                "enumDescriptions": [
+                                    "Build a GPR project",
+                                    "Run semantic checks on an Ada file",
+                                    "Clean a GPR project",
+                                    "Build a main program specified in a GPR project",
+                                    "Run a main program specified in a GPR project",
+                                    "Run a build task and a run task in sequence for a given main program"
                                 ]
                             },
                             "projectFile": {
@@ -554,19 +562,14 @@
                                 "properties": {
                                     "kind": {
                                         "enum": [
-                                            "buildAndRunMain"
+                                            "runMain"
                                         ]
                                     },
                                     "projectFile": true,
-                                    "args": true,
                                     "main": {
                                         "type": "string",
                                         "description": "Path to main source file"
                                     },
-                                    "executable": {
-                                        "type": "string",
-                                        "description": "Path to main executable file (if it cannot be computed automatically)"
-                                    },
                                     "mainArgs": {
                                         "type": "array",
                                         "items": {
@@ -576,6 +579,29 @@
                                     }
                                 },
                                 "additionalProperties": false
+                            },
+                            {
+                                "required": [
+                                    "buildTask",
+                                    "runTask"
+                                ],
+                                "$comment": "Each oneOf is evaluated regardless of the parent schema. That's why valid properties of the parent must be repeated here in order to be allowed.",
+                                "properties": {
+                                    "kind": {
+                                        "enum": [
+                                            "buildAndRunMain"
+                                        ]
+                                    },
+                                    "buildTask": {
+                                        "type": "string",
+                                        "description": "Name of the task that builds the main executable"
+                                    },
+                                    "runTask": {
+                                        "type": "string",
+                                        "description": "Name of the task that runs the main executable"
+                                    }
+                                },
+                                "additionalProperties": false
                             }
                         ]
                     }

integration/vscode/ada/src/commands.ts

@@ -8,7 +8,12 @@ import { ExtensionState } from './ExtensionState';
 import { getOrAskForProgram } from './debugConfigProvider';
 import { adaExtState, mainOutputChannel } from './extension';
 import { getProjectFileRelPath } from './helpers';
-import { CustomTaskDefinition, getEnclosingSymbol } from './taskProviders';
+import {
+    CustomTaskDefinition,
+    getConventionalTaskLabel,
+    getEnclosingSymbol,
+    isFromWorkspace,
+} from './taskProviders';
 
 export function registerCommands(context: vscode.ExtensionContext, clients: ExtensionState) {
     context.subscriptions.push(vscode.commands.registerCommand('ada.otherFile', otherFileHandler));
@@ -39,10 +44,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();
         })
     );
 
@@ -157,27 +164,6 @@ function getTaskLabel(task: vscode.Task): string {
     return isFromWorkspace(task) ? `(From Workspace) ${task.name}` : getConventionalTaskLabel(task);
 }
 
-/**
- *
- * @param task - a task
- * @returns the label typically generated for that task by vscode. For tasks not
- * defined explicitely in the workspace, this is `ada: <task name>`. For tasks
- * defined in the workspace simply return the name which should already include
- * the convention.
- */
-function getConventionalTaskLabel(task: vscode.Task): string {
-    return isFromWorkspace(task) ? task.name : `${task.source}: ${task.name}`;
-}
-
-/**
- *
- * @param task - a task
- * @returns `true` if the task is defined explicitely in the workspace's tasks.json
- */
-function isFromWorkspace(task: vscode.Task) {
-    return task.source == 'Workspace';
-}
-
 interface TaskQuickPickItem extends vscode.QuickPickItem {
     task: vscode.Task;
 }

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);
             }
         }
 
@@ -237,11 +227,6 @@ const setupCmd = [
         text: '-enable-pretty-printing',
         ignoreFailures: true,
     },
-    {
-        description: 'Set Disassembly Flavor to Intel',
-        text: '-gdb-set disassembly-flavor intel',
-        ignoreFailures: true,
-    },
 ];
 
 type QuickPickAdaMain = {
@@ -308,31 +293,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 +326,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 +349,20 @@ 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',
+        /**
+         * If the User is trying to attach to a running process, we have to
+         * assume that they already built the project. It would be detrimental
+         * to trigger an unwanted rebuild, so we don't set a preLaunchTask.
+         */
+        // preLaunchTask: adaMain ? getBuildTaskName(adaMain) : BUILD_PROJECT_TASK_NAME,
+    };
+}