Merge pull request #172 from rkeithhill/rkeithhill/is94-impl-cond-breakpoints

Fixes #94 - adds support for conditional breakpoints

Author: rkeithhill

src/PowerShellEditorServices.Protocol/DebugAdapter/Breakpoint.cs

@@ -7,10 +7,24 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter
 {
     public class Breakpoint
     {
+        /// <summary>
+        /// 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 
+        /// 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 int Line { get; set; }
 
+        public int? Column { get; set; }
+
         private Breakpoint()
         {
         }
@@ -20,8 +34,11 @@ public static Breakpoint Create(
         {
             return new Breakpoint
             {
+                Verified = breakpointDetails.Verified,
+                Message = breakpointDetails.Message,
+                Source = breakpointDetails.Source,
                 Line = breakpointDetails.LineNumber,
-                Verified = true
+                Column = breakpointDetails.ColumnNumber
             };
         }
     }

src/PowerShellEditorServices.Protocol/DebugAdapter/SetBreakpointsRequest.cs

@@ -7,11 +7,12 @@
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter
 {
-    //    /** SetBreakpoints request; value of command field is "setBreakpoints".
-    //        Sets multiple breakpoints for a single source and clears all previous breakpoints in that source.
-    //        To clear all breakpoint for a source, specify an empty array.
-    //        When a breakpoint is hit, a StoppedEvent (event type 'breakpoint') is generated.
-    //    */
+    /// <summary>
+    /// SetBreakpoints request; value of command field is "setBreakpoints".
+    /// Sets multiple breakpoints for a single source and clears all previous breakpoints in that source.
+    /// To clear all breakpoint for a source, specify an empty array.
+    /// When a breakpoint is hit, a StoppedEvent (event type 'breakpoint') is generated.
+    /// </summary>
     public class SetBreakpointsRequest
     {
         public static readonly
@@ -23,12 +24,20 @@ public class SetBreakpointsRequestArguments
     {
         public Source Source { get; set; }
 
-        public int[] Lines { get; set; }
+        public SourceBreakpoint[] Breakpoints { get; set; }
+    }
+
+    public class SourceBreakpoint
+    {
+        public int Line { get; set; }
+
+        public int? Column { get; set; }
+
+        public string Condition { get; set; }
     }
 
     public class SetBreakpointsResponseBody
     {
         public Breakpoint[] Breakpoints { get; set; }
     }
 }
-

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -172,10 +172,21 @@ protected async Task HandleSetBreakpointsRequest(
                 editorSession.Workspace.GetFile(
                     setBreakpointsParams.Source.Path);
 
+            var breakpointDetails = new BreakpointDetails[setBreakpointsParams.Breakpoints.Length];
+            for (int i = 0; i < breakpointDetails.Length; i++)
+            {
+                SourceBreakpoint srcBreakpoint = setBreakpointsParams.Breakpoints[i];
+                breakpointDetails[i] = BreakpointDetails.Create(
+                    scriptFile.FilePath, 
+                    srcBreakpoint.Line, 
+                    srcBreakpoint.Column, 
+                    srcBreakpoint.Condition);
+            }
+
             BreakpointDetails[] breakpoints =
-                await editorSession.DebugService.SetBreakpoints(
+                await editorSession.DebugService.SetLineBreakpoints(
                     scriptFile,
-                    setBreakpointsParams.Lines);
+                    breakpointDetails);
 
             await requestContext.SendResult(
                 new SetBreakpointsResponseBody

src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs

@@ -60,7 +60,11 @@ await requestContext.SendEvent(
                 null);
 
             // Now send the Initialize response to continue setup
-            await requestContext.SendResult(new InitializeResponseBody());
+            await requestContext.SendResult(
+                new InitializeResponseBody
+                {
+                    SupportsConditionalBreakpoints = true,
+                });
         }
     }
 }

src/PowerShellEditorServices/Debugging/BreakpointDetails.cs

@@ -3,9 +3,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Management.Automation;
+using Microsoft.PowerShell.EditorServices.Utility;
 
 namespace Microsoft.PowerShell.EditorServices
 {
@@ -15,11 +15,68 @@ namespace Microsoft.PowerShell.EditorServices
     /// </summary>
     public class BreakpointDetails
     {
+        /// <summary>
+        /// Gets or sets a boolean indicator that if true, breakpoint could be set 
+        /// (but not necessarily at the desired location).  
+        /// </summary>
+        public bool Verified { get; set; }
+
+        /// <summary>
+        /// Gets or set 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; }
+
+        /// <summary>
+        /// Gets the source where the breakpoint is located.  Used only for debug purposes.
+        /// </summary>
+        public string Source { get; private set; }
+
         /// <summary>
         /// Gets the line number at which the breakpoint is set.
         /// </summary>
         public int LineNumber { get; private set; }
 
+        /// <summary>
+        /// Gets the column number at which the breakpoint is set. If null, the default of 1 is used.
+        /// </summary>
+        public int? ColumnNumber { get; private set; }
+
+        /// <summary>
+        /// Gets the breakpoint condition string.
+        /// </summary>
+        public string Condition { get; private set; }
+
+        private BreakpointDetails()
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance of the BreakpointDetails class from the individual
+        /// pieces of breakpoint information provided by the client.
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="line"></param>
+        /// <param name="column"></param>
+        /// <param name="condition"></param>
+        /// <returns></returns>
+        public static BreakpointDetails Create(
+            string source, 
+            int line, 
+            int? column = null, 
+            string condition = null)
+        {
+            Validate.IsNotNull("source", source);
+
+            return new BreakpointDetails
+            {
+                Source = source,
+                LineNumber = line,
+                ColumnNumber = column,
+                Condition = condition
+            };
+        }
+
         /// <summary>
         /// Creates an instance of the BreakpointDetails class from a
         /// PowerShell Breakpoint object.
@@ -31,18 +88,26 @@ public static BreakpointDetails Create(Breakpoint breakpoint)
             Validate.IsNotNull("breakpoint", breakpoint);
 
             LineBreakpoint lineBreakpoint = breakpoint as LineBreakpoint;
-            if (lineBreakpoint != null)
-            {
-                return new BreakpointDetails
-                {
-                    LineNumber = lineBreakpoint.Line
-                };
-            }
-            else
+            if (lineBreakpoint == null)
             {
                 throw new ArgumentException(
                     "Expected breakpoint type:" + breakpoint.GetType().Name);
             }
+
+            var breakpointDetails = new BreakpointDetails
+            {
+                Verified = true,
+                Source = lineBreakpoint.Script,
+                LineNumber = lineBreakpoint.Line,
+                Condition = lineBreakpoint.Action?.ToString()
+            };
+
+            if (lineBreakpoint.Column > 0)
+            {
+                breakpointDetails.ColumnNumber = lineBreakpoint.Column;
+            }
+
+            return breakpointDetails;
         }
     }
 }