Set AllThreadsStopped appropriately

Author: andyleejordan

src/PowerShellEditorServices/Server/PsesDebugServer.cs

@@ -137,6 +137,7 @@ public async Task StartAsync()
         public void Dispose()
         {
             _powerShellContextService.IsDebugServerActive = false;
+            // TODO: If the debugger has stopped, should we clear the breakpoints?
             _debugAdapterServer.Dispose();
             _inputStream.Dispose();
             _outputStream.Dispose();

src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs

@@ -135,7 +135,8 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
                 IEnumerable<Breakpoint> setBreakpoints =
                     await _powerShellContextService.ExecuteCommandAsync<Breakpoint>(psCommand).ConfigureAwait(false);
                 configuredBreakpoints.AddRange(
-                    setBreakpoints.Select(BreakpointDetails.Create));
+                    setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint))
+                );
             }
 
             return configuredBreakpoints;

src/PowerShellEditorServices/Services/DebugAdapter/DebugEventHandlerService.cs

@@ -81,6 +81,7 @@ e.OriginalEvent.Breakpoints[0] is CommandBreakpoint
                 new StoppedEvent
                 {
                     ThreadId = 1,
+                    AllThreadsStopped = true,
                     Reason = debuggerStoppedReason
                 });
         }
@@ -117,59 +118,47 @@ private void PowerShellContext_DebuggerResumed(object sender, DebuggerResumeActi
             _debugAdapterServer.SendNotification(EventNames.Continued,
                 new ContinuedEvent
                 {
-                    AllThreadsContinued = true,
-                    ThreadId = 1
+                    ThreadId = 1,
+                    AllThreadsContinued = true
                 });
         }
 
         private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
         {
-            string reason = "changed";
-
+            // Don't send breakpoint update notifications when setting
+            // breakpoints on behalf of the client.
             if (_debugStateService.IsSetBreakpointInProgress)
             {
-                // Don't send breakpoint update notifications when setting
-                // breakpoints on behalf of the client.
                 return;
             }
 
-            switch (e.UpdateType)
-            {
-                case BreakpointUpdateType.Set:
-                    reason = "new";
-                    break;
-
-                case BreakpointUpdateType.Removed:
-                    reason = "removed";
-                    break;
-            }
-
-            var breakpoint = new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint
-            {
-                Verified = e.UpdateType != BreakpointUpdateType.Disabled
-            };
-
             if (e.Breakpoint is LineBreakpoint)
             {
-                breakpoint = LspDebugUtils.CreateBreakpoint(BreakpointDetails.Create(e.Breakpoint));
+                var breakpoint = LspDebugUtils.CreateBreakpoint(
+                    BreakpointDetails.Create(e.Breakpoint, e.UpdateType)
+                );
+
+                string reason = (e.UpdateType) switch {
+                    BreakpointUpdateType.Set => "new",
+                    BreakpointUpdateType.Removed => "removed",
+                    BreakpointUpdateType.Enabled => "changed",
+                    BreakpointUpdateType.Disabled => "changed",
+                    _ => "unknown"
+                };
+
+                _debugAdapterServer.SendNotification(
+                    EventNames.Breakpoint,
+                    new BreakpointEvent { Reason = reason, Breakpoint = breakpoint }
+                );
             }
             else if (e.Breakpoint is CommandBreakpoint)
             {
                 _logger.LogTrace("Function breakpoint updated event is not supported yet");
-                return;
             }
             else
             {
                 _logger.LogError($"Unrecognized breakpoint type {e.Breakpoint.GetType().FullName}");
-                return;
             }
-
-            _debugAdapterServer.SendNotification(EventNames.Breakpoint,
-                new BreakpointEvent
-                {
-                    Reason = reason,
-                    Breakpoint = breakpoint
-                });
         }
 
         #endregion

src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointDetails.cs

@@ -77,8 +77,11 @@ internal static BreakpointDetails Create(
         /// PowerShell Breakpoint object.
         /// </summary>
         /// <param name="breakpoint">The Breakpoint instance from which details will be taken.</param>
+        /// <param name="updateType">The BreakpointUpdateType to determine if the breakpoint is verified.</param>
         /// <returns>A new instance of the BreakpointDetails class.</returns>
-        internal static BreakpointDetails Create(Breakpoint breakpoint)
+        internal static BreakpointDetails Create(
+            Breakpoint breakpoint,
+            BreakpointUpdateType updateType = BreakpointUpdateType.Set)
         {
             Validate.IsNotNull("breakpoint", breakpoint);
 
@@ -91,7 +94,7 @@ internal static BreakpointDetails Create(Breakpoint breakpoint)
             var breakpointDetails = new BreakpointDetails
             {
                 Id = breakpoint.Id,
-                Verified = true,
+                Verified = updateType != BreakpointUpdateType.Disabled,
                 Source = lineBreakpoint.Script,
                 LineNumber = lineBreakpoint.Line,
                 ColumnNumber = lineBreakpoint.Column,

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/ThreadsHandler.cs

@@ -20,7 +20,7 @@ public Task<ThreadsResponse> Handle(ThreadsArguments request, CancellationToken
             {
                 // TODO: OmniSharp supports multithreaded debugging (where
                 // multiple threads can be debugged at once), but we don't. This
-                // means we always need to set AllThreadsStoppped and
+                // means we always need to set AllThreadsStopped and
                 // AllThreadsContinued in our events. But if we one day support
                 // multithreaded debugging, we'd need a way to associate
                 // debugged runspaces with .NET threads in a consistent way.