Add BreakpointEvent to be sent when breakpoints change in session

This change adds the BreakpointEvent message type to the debug adapter
and wires it up to be sent anytime breakpoints change in the editing
session.  This allows the user to call Set-PSBreakpoint in the
integrated console to add new breakpoints and then see them be set in
the editor UI.

Resolves PowerShell/vscode-powershell#660

Author: daviwil

src/PowerShellEditorServices.Protocol/DebugAdapter/Breakpoint.cs

@@ -9,19 +9,21 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter
 {
     public class Breakpoint
     {
+        public int? Id { get; set; }
+
         /// <summary>
-        /// Gets an boolean indicator that if true, breakpoint could be set 
-        /// (but not necessarily at the desired location).  
+        /// Gets an boolean indicator that if true, breakpoint could be set
+        /// (but not necessarily at the desired location).
         /// </summary>
         public bool Verified { get; set; }
 
         /// <summary>
-        /// Gets an optional message about the state of the breakpoint. This is shown to the user 
+        /// Gets an optional message about the state of the breakpoint. This is shown to the user
         /// and can be used to explain why a breakpoint could not be verified.
         /// </summary>
         public string Message { get; set; }
 
-        public string Source { get; set; }
+        public Source Source { get; set; }
 
         public int? Line { get; set; }
 
@@ -38,9 +40,10 @@ public static Breakpoint Create(
 
             return new Breakpoint
             {
+                Id = breakpointDetails.Id,
                 Verified = breakpointDetails.Verified,
                 Message = breakpointDetails.Message,
-                Source = breakpointDetails.Source,
+                Source = new Source { Path = breakpointDetails.Source },
                 Line = breakpointDetails.LineNumber,
                 Column = breakpointDetails.ColumnNumber
             };
@@ -70,7 +73,7 @@ public static Breakpoint Create(
             return new Breakpoint {
                 Verified = verified,
                 Message = message,
-                Source = source,
+                Source = new Source { Path = source },
                 Line = sourceBreakpoint.Line,
                 Column = sourceBreakpoint.Column
             };

src/PowerShellEditorServices.Protocol/DebugAdapter/BreakpointEvent.cs

@@ -0,0 +1,20 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter
+{
+    public class BreakpointEvent
+    {
+        public static readonly
+            NotificationType<BreakpointEvent, object> Type =
+            NotificationType<BreakpointEvent, object>.Create("breakpoint");
+
+        public string Reason { get; set; }
+
+        public Breakpoint Breakpoint { get; set; }
+    }
+}

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -36,6 +36,7 @@ public class DebugAdapter
         private IMessageSender messageSender;
         private IMessageHandlers messageHandlers;
         private bool isInteractiveDebugSession;
+        private bool setBreakpointInProgress;
         private RequestContext<object> disconnectRequestContext = null;
 
         public DebugAdapter(
@@ -522,10 +523,24 @@ await requestContext.SendResult(
             BreakpointDetails[] updatedBreakpointDetails = breakpointDetails;
             if (!this.noDebug)
             {
-                updatedBreakpointDetails =
-                    await editorSession.DebugService.SetLineBreakpoints(
-                        scriptFile,
-                        breakpointDetails);
+                this.setBreakpointInProgress = true;
+
+                try
+                {
+                    updatedBreakpointDetails =
+                        await editorSession.DebugService.SetLineBreakpoints(
+                            scriptFile,
+                            breakpointDetails);
+                }
+                catch (Exception e)
+                {
+                    // Log whatever the error is
+                    Logger.WriteException("Caught error while setting breakpoints in SetBreakpoints handler", e);
+                }
+                finally
+                {
+                    this.setBreakpointInProgress = false;
+                }
             }
 
             await requestContext.SendResult(
@@ -855,13 +870,15 @@ await this.messageSender.SendEvent(
         private void RegisterEventHandlers()
         {
             this.editorSession.PowerShellContext.RunspaceChanged += this.powerShellContext_RunspaceChanged;
+            this.editorSession.DebugService.BreakpointUpdated += DebugService_BreakpointUpdated;
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
             this.editorSession.PowerShellContext.DebuggerResumed += this.powerShellContext_DebuggerResumed;
         }
 
         private void UnregisterEventHandlers()
         {
             this.editorSession.PowerShellContext.RunspaceChanged -= this.powerShellContext_RunspaceChanged;
+            this.editorSession.DebugService.BreakpointUpdated -= DebugService_BreakpointUpdated;
             this.editorSession.DebugService.DebuggerStopped -= this.DebugService_DebuggerStopped;
             this.editorSession.PowerShellContext.DebuggerResumed -= this.powerShellContext_DebuggerResumed;
         }
@@ -940,6 +957,42 @@ await this.messageSender.SendEvent(
                 });
         }
 
+        private async void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
+        {
+            string reason = "changed";
+
+            if (this.setBreakpointInProgress)
+            {
+                // 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 = Protocol.DebugAdapter.Breakpoint.Create(
+                BreakpointDetails.Create(e.Breakpoint));
+
+            breakpoint.Verified = e.UpdateType != BreakpointUpdateType.Disabled;
+
+            await this.messageSender.SendEvent(
+                BreakpointEvent.Type,
+                new BreakpointEvent
+                {
+                    Reason = reason,
+                    Breakpoint = breakpoint
+                });
+        }
+
         #endregion
 
         #region Events

src/PowerShellEditorServices/Debugging/BreakpointDetails.cs

@@ -15,6 +15,12 @@ namespace Microsoft.PowerShell.EditorServices
     /// </summary>
     public class BreakpointDetails : BreakpointDetailsBase
     {
+        /// <summary>
+        /// Gets the unique ID of the breakpoint.
+        /// </summary>
+        /// <returns></returns>
+        public int Id { get; private set; }
+
         /// <summary>
         /// Gets the source where the breakpoint is located.  Used only for debug purposes.
         /// </summary>
@@ -83,6 +89,7 @@ public static BreakpointDetails Create(Breakpoint breakpoint)
 
             var breakpointDetails = new BreakpointDetails
             {
+                Id = breakpoint.Id,
                 Verified = true,
                 Source = lineBreakpoint.Script,
                 LineNumber = lineBreakpoint.Line,

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -195,7 +195,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                     psCommand.AddParameter("Line", breakpoint.LineNumber);
 
                     // Check if the user has specified the column number for the breakpoint.
-                    if (breakpoint.ColumnNumber.HasValue)
+                    if (breakpoint.ColumnNumber.HasValue && breakpoint.ColumnNumber.Value > 0)
                     {
                         // It bums me out that PowerShell will silently ignore a breakpoint
                         // where either the line or the column is invalid.  I'd rather have an
@@ -368,7 +368,7 @@ public VariableDetailsBase[] GetVariables(int variableReferenceId)
                 logger.Write(LogLevel.Warning, $"Received request for variableReferenceId {variableReferenceId} that is out of range of valid indices.");
                 return new VariableDetailsBase[0];
             }
-            
+
             VariableDetailsBase parentVariable = this.variables[variableReferenceId];
             if (parentVariable.IsExpandable)
             {