Add attachDotnetDebugger debug option

Author: JustinGrote

package.json

@@ -522,6 +522,11 @@
                 "type": "boolean",
                 "description": "Determines whether a temporary PowerShell Extension Terminal is created for each debugging session, useful for debugging PowerShell classes and binary modules.  Overrides the user setting 'powershell.debugging.createTemporaryIntegratedConsole'.",
                 "default": false
+              },
+              "attachDotnetDebugger": {
+                "type": "boolean",
+                "description": "If specified, a C# debug session will be started and attach to the new temporary PSIC. This does nothing unless createTemporaryIntegratedConsole is also specified.",
+                "default": false
               }
             }
           },

src/features/DebugSession.ts

@@ -283,14 +283,149 @@ export class DebugSessionFeature extends LanguageClientConsumer
             }
         }
 
-        if (!config.runspaceId && !config.runspaceName) {
-            config.runspaceId = await vscode.commands.executeCommand("PowerShell.PickRunspace", config.processId);
-            // No runspace selected. Cancel attach.
-            if (!config.runspaceId) {
-                return null;
+            if (!config.runspaceId && !config.runspaceName) {
+                config.runspaceId = await vscode.commands.executeCommand("PowerShell.PickRunspace", config.processId);
+
+                // No runspace selected. Cancel attach.
+                if (!config.runspaceId) {
+                    return null;
+                }
             }
         }
 
+        // TODO: Use a named debug configuration.
+        if (generateLaunchConfig) {
+            // No launch.json, create the default configuration for both unsaved (Untitled) and saved documents.
+            config.type = "PowerShell";
+            config.name = "PowerShell: Launch Current File";
+            config.request = "launch";
+            config.args = [];
+
+            config.script =
+                currentDocument.isUntitled
+                    ? currentDocument.uri.toString()
+                    : currentDocument.fileName;
+
+            if (config.createTemporaryIntegratedConsole) {
+                // For a folder-less workspace, vscode.workspace.rootPath will be undefined.
+                // PSES will convert that undefined to a reasonable working dir.
+                config.cwd =
+                    currentDocument.isUntitled
+                        ? vscode.workspace.rootPath
+                        : currentDocument.fileName;
+
+            } else {
+                // If the non-temp integrated console is being used, default to the current working dir.
+                config.cwd = "";
+            }
+        }
+
+        if (config.request === "launch") {
+            // For debug launch of "current script" (saved or unsaved), warn before starting the debugger if either
+            // A) there is not an active document
+            // B) the unsaved document's language type is not PowerShell
+            // C) the saved document's extension is a type that PowerShell can't debug.
+            if (debugCurrentScript) {
+
+                if (currentDocument === undefined) {
+                    const msg = "To debug the \"Current File\", you must first open a " +
+                                "PowerShell script file in the editor.";
+                    vscode.window.showErrorMessage(msg);
+                    return;
+                }
+
+                if (currentDocument.isUntitled) {
+                    if (config.createTemporaryIntegratedConsole) {
+                        const msg = "Debugging Untitled files in a temporary console is currently not supported.";
+                        vscode.window.showErrorMessage(msg);
+                        return;
+                    }
+
+                    if (currentDocument.languageId === "powershell") {
+                        if (!generateLaunchConfig) {
+                            // Cover the case of existing launch.json but unsaved (Untitled) document.
+                            // In this case, vscode.workspace.rootPath will not be undefined.
+                            config.script = currentDocument.uri.toString();
+                            config.cwd = vscode.workspace.rootPath;
+                        }
+                    } else {
+                        const msg = "To debug '" + currentDocument.fileName + "', change the document's " +
+                                    "language mode to PowerShell or save the file with a PowerShell extension.";
+                        vscode.window.showErrorMessage(msg);
+                        return;
+                    }
+                } else {
+                    let isValidExtension = false;
+                    const extIndex = currentDocument.fileName.lastIndexOf(".");
+                    if (extIndex !== -1) {
+                        const ext = currentDocument.fileName.substr(extIndex + 1).toUpperCase();
+                        isValidExtension = (ext === "PS1" || ext === "PSM1");
+                    }
+
+                    if ((currentDocument.languageId !== "powershell") || !isValidExtension) {
+                        let docPath = currentDocument.fileName;
+                        const workspaceRootPath = vscode.workspace.rootPath;
+                        if (currentDocument.fileName.startsWith(workspaceRootPath)) {
+                            docPath = currentDocument.fileName.substring(vscode.workspace.rootPath.length + 1);
+                        }
+
+                        const msg = "PowerShell does not support debugging this file type: '" + docPath + "'.";
+                        vscode.window.showErrorMessage(msg);
+                        return;
+                    }
+
+                    if (config.script === "${file}") {
+                        config.script = currentDocument.fileName;
+                    }
+                }
+            }
+
+            // NOTE: There is a tight coupling to a weird setting in
+            // `package.json` for the Launch Current File configuration where
+            // the default cwd is set to ${file}.
+            if ((currentDocument !== undefined) && (config.cwd === "${file}")) {
+                config.cwd = currentDocument.fileName;
+            }
+        }
+
+        // Prevent the Debug Console from opening
+        config.internalConsoleOptions = "neverOpen";
+
+        // Create or show the interactive console
+        vscode.commands.executeCommand("PowerShell.ShowSessionConsole", true);
+
+        const sessionFilePath = utils.getDebugSessionFilePath();
+
+        if (config.createTemporaryIntegratedConsole) {
+            if (this.tempDebugProcess) {
+                this.tempDebugProcess.dispose();
+            }
+
+            this.tempDebugProcess =
+                this.sessionManager.createDebugSessionProcess(
+                    sessionFilePath,
+                    settings);
+
+            this.tempSessionDetails = await this.tempDebugProcess.start(`DebugSession-${this.sessionCount++}`);
+            utils.writeSessionFile(sessionFilePath, this.tempSessionDetails);
+
+            if (config.attachDotnetDebugger) {
+                // Will wait until the process is started and available before attaching
+                const pid = await this.tempDebugProcess.getPid();
+
+                await vscode.debug.startDebugging(undefined, {
+                    name: "Dotnet Debugger: PSIC Temporary Console",
+                    type: "coreclr",
+                    request: "attach",
+                    processId: pid
+                });
+                this.logger.write(`Attached dotnet debugger to process ${pid}`)
+            }
+
+        } else {
+            utils.writeSessionFile(sessionFilePath, this.sessionManager.getSessionDetails());
+        }
+
         return config;
     }
 }

src/process.ts

@@ -134,8 +134,13 @@ export class PowerShellProcess {
         return sessionDetails;
     }
 
+    // Returns the process Id of the consoleTerminal
+    public async getPid() {
+        return await this.consoleTerminal.processId
+    }
+
     public showTerminal(preserveFocus?: boolean) {
-        this.consoleTerminal?.show(preserveFocus);
+        this.consoleTerminal?.show(preserveFocus)
     }
 
     public async dispose() {