Get debugging to work again

Author: rjmholt

src/PowerShellEditorServices/Services/PowerShell/Console/ConsoleReplRunner.cs

@@ -1,5 +1,4 @@
 using Microsoft.Extensions.Logging;
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Context;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
 using System;

src/PowerShellEditorServices/Services/PowerShell/Debugging/PowerShellDebugContext.cs

@@ -116,6 +116,7 @@ public void ProcessDebuggerResult(DebuggerCommandResults debuggerResult)
         {
             if (debuggerResult.ResumeAction != null)
             {
+                SetDebugResuming(debuggerResult.ResumeAction.Value);
                 RaiseDebuggerResumingEvent(new DebuggerResumingEventArgs(debuggerResult.ResumeAction.Value));
             }
         }

src/PowerShellEditorServices/Services/PowerShell/Execution/PipelineThreadExecutor.cs

@@ -29,8 +29,6 @@ internal class PipelineThreadExecutor
 
         private readonly EditorServicesConsolePSHost _psesHost;
 
-        private readonly PowerShellDebugContext _debugContext;
-
         private readonly IReadLineProvider _readLineProvider;
 
         private readonly HostStartupInfo _hostInfo;
@@ -58,7 +56,6 @@ public PipelineThreadExecutor(
             _logger = loggerFactory.CreateLogger<PipelineThreadExecutor>();
             _hostInfo = hostInfo;
             _psesHost = psesHost;
-            _debugContext = psesHost.DebugContext;
             _readLineProvider = readLineProvider;
             _consumerThreadCancellationSource = new CancellationTokenSource();
             _executionQueue = new BlockingCollection<ISynchronousTask>();
@@ -187,18 +184,18 @@ private void RunNestedLoop(in CancellationScope cancellationScope)
 
         private void RunDebugLoop(in CancellationScope cancellationScope)
         {
-            _debugContext.EnterDebugLoop(cancellationScope.CancellationToken);
+            _psesHost.DebugContext.EnterDebugLoop(cancellationScope.CancellationToken);
             try
             {
                 // Run commands, but cancelling our blocking wait if the debugger resumes
-                foreach (ISynchronousTask task in _executionQueue.GetConsumingEnumerable(_debugContext.OnResumeCancellationToken))
+                foreach (ISynchronousTask task in _executionQueue.GetConsumingEnumerable(_psesHost.DebugContext.OnResumeCancellationToken))
                 {
                     // We don't want to cancel the current command when the debugger resumes,
                     // since that command will be resuming the debugger.
                     // Instead let it complete and check the cancellation afterward.
                     RunTaskSynchronously(task, cancellationScope.CancellationToken);
 
-                    if (_debugContext.OnResumeCancellationToken.IsCancellationRequested)
+                    if (_psesHost.DebugContext.OnResumeCancellationToken.IsCancellationRequested)
                     {
                         break;
                     }
@@ -210,7 +207,7 @@ private void RunDebugLoop(in CancellationScope cancellationScope)
             }
             finally
             {
-                _debugContext.ExitDebugLoop();
+                _psesHost.DebugContext.ExitDebugLoop();
             }
         }
 

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs

@@ -36,6 +36,8 @@ internal class EditorServicesConsolePSHost : PSHost, IHostSupportsInteractiveSes
 
         private readonly ReadLineProvider _readLineProvider;
 
+        private readonly Stack<KeyValuePair<Runspace, RunspaceInfo>> _runspacesInUse;
+
         private string _localComputerName;
 
         private int _hostStarted = 0;
@@ -48,20 +50,22 @@ public EditorServicesConsolePSHost(
             _logger = loggerFactory.CreateLogger<EditorServicesConsolePSHost>();
             _psFrameStack = new Stack<PowerShellContextFrame>();
             _psFactory = new PowerShellFactory(loggerFactory, this);
+            _runspacesInUse = new Stack<KeyValuePair<Runspace, RunspaceInfo>>();
             _hostInfo = hostInfo;
             Name = hostInfo.Name;
             Version = hostInfo.Version;
 
             _readLineProvider = new ReadLineProvider(loggerFactory);
             _pipelineExecutor = new PipelineThreadExecutor(loggerFactory, hostInfo, this, _readLineProvider);
             ExecutionService = new PowerShellExecutionService(loggerFactory, this, _pipelineExecutor);
-            DebugContext = new PowerShellDebugContext(loggerFactory, languageServer, this,  _consoleReplRunner);
             UI = new EditorServicesConsolePSHostUserInterface(loggerFactory, _readLineProvider, hostInfo.PSHost.UI);
 
             if (hostInfo.ConsoleReplEnabled)
             {
                 _consoleReplRunner = new ConsoleReplRunner(loggerFactory, this, _readLineProvider, ExecutionService);
             }
+
+            DebugContext = new PowerShellDebugContext(loggerFactory, languageServer, this,  _consoleReplRunner);
         }
 
         public override CultureInfo CurrentCulture => _hostInfo.PSHost.CurrentCulture;
@@ -217,9 +221,28 @@ private void SetExit()
 
         private void PushPowerShellAndRunLoop(SMA.PowerShell pwsh, PowerShellFrameType frameType)
         {
+            RunspaceInfo runspaceInfo = null;
+            if (_runspacesInUse.Count > 0)
+            {
+                // This is more than just an optimization.
+                // When debugging, we cannot execute PowerShell directly to get this information;
+                // trying to do so will block on the command that called us, deadlocking execution.
+                // Instead, since we are reusing the runspace, we reuse that runspace's info as well.
+                KeyValuePair<Runspace, RunspaceInfo> currentRunspace = _runspacesInUse.Peek();
+                if (currentRunspace.Key == pwsh.Runspace)
+                {
+                    runspaceInfo = currentRunspace.Value;
+                }
+            }
+
+            if (runspaceInfo is null)
+            {
+                RunspaceOrigin runspaceOrigin = pwsh.Runspace.RunspaceIsRemote ? RunspaceOrigin.EnteredProcess : RunspaceOrigin.Local;
+                runspaceInfo = RunspaceInfo.CreateFromPowerShell(_logger, pwsh, runspaceOrigin, _localComputerName);
+                _runspacesInUse.Push(new KeyValuePair<Runspace, RunspaceInfo>(pwsh.Runspace, runspaceInfo));
+            }
+
             // TODO: Improve runspace origin detection here
-            RunspaceOrigin runspaceOrigin = pwsh.Runspace.RunspaceIsRemote ? RunspaceOrigin.EnteredProcess : RunspaceOrigin.Local;
-            var runspaceInfo = RunspaceInfo.CreateFromPowerShell(_logger, pwsh, runspaceOrigin, _localComputerName);
             PushPowerShellAndRunLoop(new PowerShellContextFrame(pwsh, runspaceInfo, frameType));
         }