Stop debugger on task cancellation too

This synchronizes the `DebugContext` and LSP debug server state during
both edge cases:

1. A REPL happened, the debugger was marked active, and the debugger is
   now no longer running (it was quit, detached, or continued to the end
   of the script or function).

2. A user manually cancelled a task, and it was running under the
   "debugger" (whether or not the PowerShell debugger was active).

Author: andyleejordan

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

@@ -47,19 +47,26 @@ public PowerShellDebugContext(
             _psesHost = psesHost;
         }
 
+        /// <summary>
+        /// Tracks if the debugger is currently stopped at a breakpoint.
+        /// </summary>
         public bool IsStopped { get; private set; }
 
         /// <summary>
-        /// Tracks the state of the LSP debug server (not the PowerShell debugger).
+        /// Tracks the state of the PowerShell debugger. This is NOT the same as <see
+        /// cref="Debugger.IsActive">, which is true whenever breakpoints are set. Instead, this is
+        /// set to true when the first <see cref="PsesInternalHost.OnDebuggerStopped"> event is
+        /// fired, and set to false in <see cref="PsesInternalHost.DoOneRepl"> when <see
+        /// cref="Debugger.IsInBreakpoint"> is false. This is used to send the
+        /// 'powershell/stopDebugger' notification to the LSP debug server in the cases where the
+        /// server was started or ended by the PowerShell session instead of by Code's GUI.
         /// </summary>
-        public bool IsDebugServerActive { get; set; }
+        public bool IsActive { get; set; }
 
         /// <summary>
-        /// Tracks if the PowerShell session started the debug server itself (true), or if it was
-        /// started by an LSP notification (false). Essentially, this marks if we're responsible for
-        /// stopping the debug server (and thus need to send a notification to do so).
+        /// Tracks the state of the LSP debug server (not the PowerShell debugger).
         /// </summary>
-        public bool OwnsDebugServerState { get; set; }
+        public bool IsDebugServerActive { get; set; }
 
         public DebuggerStopEventArgs LastStopEventArgs { get; private set; }
 

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

@@ -601,12 +601,14 @@ private void DoOneRepl(CancellationToken cancellationToken)
                 return;
             }
 
-            // If we started the debug server, then on each REPL we need to check if we're still
-            // actively debugging, and if not, stop the server.
-            if (DebugContext.OwnsDebugServerState && !CurrentRunspace.Runspace.Debugger.InBreakpoint)
+            // We use the REPL as a poll to check if the debug context is active but PowerShell
+            // indicates we're no longer debugging. This happens when PowerShell was used to start
+            // the debugger (instead of using a Code launch configuration) via Wait-Debugger or
+            // simply hitting a PSBreakpoint. We need to synchronize the state and stop the debug
+            // context (and likely the debug server).
+            if (DebugContext.IsActive && !CurrentRunspace.Runspace.Debugger.InBreakpoint)
             {
-                DebugContext.OwnsDebugServerState = false;
-                _languageServer?.SendNotification("powerShell/stopDebugger");
+                StopDebugContext();
             }
 
             // When a task must run in the foreground, we cancel out of the idle loop and return to the top level.
@@ -633,8 +635,7 @@ private void DoOneRepl(CancellationToken cancellationToken)
                 // However, we must distinguish the last two scenarios, since PSRL will not print a new line in those cases.
                 if (string.IsNullOrEmpty(userInput))
                 {
-                    if (cancellationToken.IsCancellationRequested
-                        || LastKeyWasCtrlC())
+                    if (cancellationToken.IsCancellationRequested || LastKeyWasCtrlC())
                     {
                         UI.WriteLine();
                     }
@@ -834,7 +835,12 @@ private void OnPowerShellIdle(CancellationToken idleCancellationToken)
 
         private void OnCancelKeyPress(object sender, ConsoleCancelEventArgs args)
         {
+            // We need to cancel the current task.
             _cancellationContext.CancelCurrentTask();
+
+            // If the current task was running under the debugger, we need to synchronize the
+            // cancelation with our debug context (and likely the debug server).
+            StopDebugContext();
         }
 
         private ConsoleKeyInfo ReadKey(bool intercept)
@@ -854,13 +860,26 @@ private bool LastKeyWasCtrlC()
                 && _lastKey.Value.IsCtrlC();
         }
 
+        private void StopDebugContext()
+        {
+            // We are officially stopping the debugger.
+            DebugContext.IsActive = false;
+
+            // If the debug server is active, we need to synchronize state and stop it.
+            if (DebugContext.IsDebugServerActive)
+            {
+                _languageServer?.SendNotification("powerShell/stopDebugger");
+            }
+        }
+
         private void OnDebuggerStopped(object sender, DebuggerStopEventArgs debuggerStopEventArgs)
         {
+            // The debugger has officially started. We use this to later check if we should stop it.
+            DebugContext.IsActive = true;
+
+            // If the debug server is NOT active, we need to synchronize state and start it.
             if (!DebugContext.IsDebugServerActive)
             {
-                // If the we've hit a breakpoint and the debug server is not active, then we need to
-                // start it (and own stopping it later).
-                DebugContext.OwnsDebugServerState = true;
                 _languageServer?.SendNotification("powerShell/startDebugger");
             }