Cleanup flow and breakout temporary console to dedicated functions

Author: JustinGrote

src/features/DebugSession.ts

@@ -3,17 +3,25 @@
 
 import vscode = require("vscode");
 import {
-    CancellationToken, DebugConfiguration, DebugConfigurationProvider,
-    ExtensionContext, WorkspaceFolder
+    CancellationToken,
+    DebugAdapterDescriptor,
+    DebugAdapterDescriptorFactory,
+    DebugAdapterExecutable,
+    DebugAdapterNamedPipeServer,
+    DebugConfiguration,
+    DebugConfigurationProvider,
+    DebugSession,
+    ExtensionContext,
+    WorkspaceFolder
 } from "vscode";
 import { NotificationType, RequestType } from "vscode-languageclient";
 import { LanguageClient } from "vscode-languageclient/node";
-import { getPlatformDetails, OperatingSystem } from "../platform";
+import { LanguageClientConsumer } from "../languageClientConsumer";
+import { ILogger } from "../logging";
+import { OperatingSystem, getPlatformDetails } from "../platform";
 import { PowerShellProcess } from "../process";
 import { IEditorServicesSessionDetails, SessionManager, SessionStatus } from "../session";
 import { getSettings } from "../settings";
-import { ILogger } from "../logging";
-import { LanguageClientConsumer } from "../languageClientConsumer";
 import path = require("path");
 import utils = require("../utils");
 
@@ -31,7 +39,7 @@ enum DebugConfig {
 }
 
 export class DebugSessionFeature extends LanguageClientConsumer
-    implements DebugConfigurationProvider, vscode.DebugAdapterDescriptorFactory {
+    implements DebugConfigurationProvider, DebugAdapterDescriptorFactory {
 
     private sessionCount = 1;
     private tempDebugProcess: PowerShellProcess | undefined;
@@ -72,12 +80,14 @@ export class DebugSessionFeature extends LanguageClientConsumer
         context.subscriptions.push(vscode.debug.registerDebugAdapterDescriptorFactory("PowerShell", this));
     }
 
-    createDebugAdapterDescriptor(
-        session: vscode.DebugSession,
-        _executable: vscode.DebugAdapterExecutable | undefined): vscode.ProviderResult<vscode.DebugAdapterDescriptor> {
+    // This is our factory entrypoint hook to when a debug session starts, and where we will lazy initialize everything needed to do the debugging such as a temporary console if required
+    public async createDebugAdapterDescriptor(
+        session: DebugSession,
+        _executable: DebugAdapterExecutable | undefined): Promise<DebugAdapterDescriptor | undefined> {
+        // NOTE: A Promise meets the shape of a ProviderResult, which allows us to make this method async.
 
         const sessionDetails = session.configuration.createTemporaryIntegratedConsole
-            ? this.tempSessionDetails
+            ? await this.createTemporaryIntegratedConsole(session)
             : this.sessionManager.getSessionDetails();
 
         if (sessionDetails === undefined) {
@@ -88,7 +98,7 @@ export class DebugSessionFeature extends LanguageClientConsumer
         this.logger.writeVerbose(`Connecting to pipe: ${sessionDetails.debugServicePipeName}`);
         this.logger.writeVerbose(`Debug configuration: ${JSON.stringify(session.configuration)}`);
 
-        return new vscode.DebugAdapterNamedPipeServer(sessionDetails.debugServicePipeName);
+        return new DebugAdapterNamedPipeServer(sessionDetails.debugServicePipeName);
     }
 
     public dispose() {
@@ -114,6 +124,59 @@ export class DebugSessionFeature extends LanguageClientConsumer
         ];
     }
 
+    public async createTemporaryIntegratedConsole(session: DebugSession) {
+        const settings = getSettings();
+        this.tempDebugProcess = await this.sessionManager.createDebugSessionProcess(settings);
+        this.tempSessionDetails = await this.tempDebugProcess.start(`DebugSession-${this.sessionCount++}`);
+
+        // NOTE: Dotnet attach debugging is only currently supported if a temporary console is used, otherwise we get lots of lock conflicts from loading the assemblies
+        if (session.configuration.attachDotnetDebugger) {
+            if (!vscode.extensions.getExtension("ms-dotnettools.csharp")) {
+                void this.logger.writeAndShowError("You specified attachDotnetDebugger in your PowerShell Launch configuration but the C# extension is not installed. Please install the C# extension and try again.");
+                return undefined;
+            }
+
+            // Will wait until the process is started and available before attaching
+            const pid = await this.tempDebugProcess.getPid();
+            if (pid === undefined) {
+                void this.logger.writeAndShowError("Attach Dotnet Debugger was specified but the PowerShell temporary debug session failed to start. This is probably a bug.");
+                return undefined;
+            }
+
+            const dotnetDebuggerConfig = this.getDotnetNamedConfigOrDefault(session, pid);
+            if (dotnetDebuggerConfig === undefined) {
+                void this.logger.writeAndShowError(`You specified dotnetDebuggerConfigName in your PowerShell Launch configuration but a matching launch config was not found. Please ensure you have a coreclr attach config with the name ${session.configuration.dotnetDebuggerConfigName} in your launch.json file or remove dotnetDebuggerConfigName from your PowerShell Launch configuration to use the defaults`);
+                return undefined;
+            }
+
+            // Start a child debug session to attach the dotnet debugger
+            // TODO: Accomodate multi-folder workspaces if the C# code is in a different workspace folder
+            await vscode.debug.startDebugging(undefined, dotnetDebuggerConfig, session);
+            this.logger.write(`Attached dotnet debugger to process ${pid}`);
+        }
+        return this.tempSessionDetails;
+    }
+
+    public getDotnetNamedConfigOrDefault(session: DebugSession, pid: number) {
+        if (session.configuration.dotnetDebuggerConfigName) {
+            const debugConfigs = vscode.workspace.getConfiguration("launch").get<DebugConfiguration[]>("configurations") ?? [];
+
+            return debugConfigs.find((config) => {
+                return config.type === "coreclr"
+                    && config.request === "attach"
+                    && config.name === config.dotnetDebuggerConfigName;
+            });
+        }
+
+        // Default debugger config if none provided
+        return {
+            name: "Dotnet Debugger: PSIC Temporary Console",
+            type: "coreclr",
+            request: "attach",
+            processId: pid
+        };
+    }
+
     public async provideDebugConfigurations(
         _folder: WorkspaceFolder | undefined,
         _token?: CancellationToken): Promise<DebugConfiguration[]> {
@@ -159,66 +222,8 @@ export class DebugSessionFeature extends LanguageClientConsumer
         config: DebugConfiguration,
         _token?: CancellationToken): Promise<DebugConfiguration | undefined> {
 
-        // Prevent the Debug Console from opening
-        config.internalConsoleOptions = "neverOpen";
-
         // NOTE: We intentionally do not touch the `cwd` setting of the config.
 
-        // If the createTemporaryIntegratedConsole field is not specified in the
-        // launch config, set the field using the value from the corresponding
-        // setting. Otherwise, the launch config value overrides the setting.
-        //
-        // Also start the temporary process and console for this configuration.
-        const settings = getSettings();
-        config.createTemporaryIntegratedConsole =
-            config.createTemporaryIntegratedConsole ??
-            settings.debugging.createTemporaryIntegratedConsole;
-
-        if (config.createTemporaryIntegratedConsole) {
-            this.tempDebugProcess = await this.sessionManager.createDebugSessionProcess(settings);
-            this.tempSessionDetails = await this.tempDebugProcess.start(`DebugSession-${this.sessionCount++}`);
-
-            // This only works if in a temporary console
-            if (config.attachDotnetDebugger) {
-
-                if (!vscode.extensions.getExtension("ms-dotnettools.csharp")) {
-                    this.logger.writeAndShowError("You specified attachDotnetDebugger in your PowerShell Launch configuration but the C# extension is not installed. Please install the C# extension and try again.");
-                    return undefined;
-                }
-
-                // Will wait until the process is started and available before attaching
-                const pid = await this.tempDebugProcess.getPid();
-
-                if (config.dotnetDebuggerConfigName) {
-                    const debugConfigs = vscode.workspace.getConfiguration('launch').get<DebugConfiguration[]>('configurations') || [];
-
-                    const configMatch = debugConfigs.find((config) => {
-                        return config.type === "coreclr"
-                            && config.request === "attach"
-                            && config.name === config.dotnetDebuggerConfigName;
-                    });
-
-                    if (!configMatch) {
-                        this.logger.writeAndShowError(`You specified dotnetDebuggerConfigName in your PowerShell Launch configuration but a matching launch config was not found. Please ensure you have a coreclr attach config with the name ${config.dotnetDebuggerConfigName} in your launch.json file or remove dotnetDebuggerConfigName from your PowerShell Launch configuration to use the defaults`);
-
-                        // Fail the debug session by returning undefined
-                        return undefined;
-                    }
-                    return configMatch;
-                }
-
-                // Start a secondary debug session to attach the dotnet debugger
-                // TODO: Accomodate multi-folder workspaces if the C# code is in a different workspace folder
-                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}`);
-            }
-        }
-
         if (!config.request) {
             // No launch.json, create the default configuration for both unsaved
             // (Untitled) and saved documents.
@@ -227,9 +232,15 @@ export class DebugSessionFeature extends LanguageClientConsumer
             config.current_document = true;
         }
 
+        // Prevent the Debug Console from opening
+        config.internalConsoleOptions = "neverOpen";
+
+        const settings = getSettings();
+        config.createTemporaryIntegratedConsole ??= settings.debugging.createTemporaryIntegratedConsole;
+
         if (config.script === "${file}" || config.script === "${relativeFile}") {
             if (vscode.window.activeTextEditor === undefined) {
-                void this.logger.writeAndShowError("To debug the 'Current File', you must first open a PowerShell script file in the editor.");
+                await this.logger.writeAndShowError("To debug the 'Current File', you must first open a PowerShell script file in the editor.");
                 return undefined;
             }
             config.current_document = true;
@@ -259,6 +270,7 @@ export class DebugSessionFeature extends LanguageClientConsumer
             return null;
         }
 
+        // TODO: This should move to createDebugAdapterDescriptor
         if (resolvedConfig) {
             // Start the PowerShell session if needed.
             if (this.sessionManager.getSessionStatus() !== SessionStatus.Running) {