Fixes #173 - implementation for function breakpoints

This commit also introduces support for the configurationDone request.  In fact, due to the order in which set*Breakpoints requests and the launch request come in, we now defer the execution of the script until we receive the configurationDone request.  When we executed from the launch request, the debug host would appear to hang.  It did not like executing Set/Remove-PSBreakpoint commands when the host debugger was running (not in a stopped state) AFAICT.

This commit has a known issue with VSCode mixing up which breakpoint has a condition associated with it when you add/remove a breakpoint (see microsoft/vscode#3558).  The next commit will fix this issue.

Author: rkeithhill

src/PowerShellEditorServices.Protocol/Client/DebugAdapterClientBase.cs

@@ -17,14 +17,15 @@ public DebugAdapterClient(ChannelBase clientChannel)
         {
         }
 
-        public Task LaunchScript(string scriptFilePath)
+        public async Task LaunchScript(string scriptFilePath)
         {
-            return this.SendRequest(
+            await this.SendRequest(
                 LaunchRequest.Type,
-                new LaunchRequestArguments
-                {
+                new LaunchRequestArguments {
                     Program = scriptFilePath
                 });
+
+            await this.SendRequest(ConfigurationDoneRequest.Type, null);
         }
 
         protected override async Task OnStart()

src/PowerShellEditorServices.Protocol/DebugAdapter/Breakpoint.cs

@@ -21,7 +21,7 @@ public class Breakpoint
 
         public string Source { get; set; }
 
-        public int Line { get; set; }
+        public int? Line { get; set; }
 
         public int? Column { get; set; }
 
@@ -41,5 +41,14 @@ public static Breakpoint Create(
                 Column = breakpointDetails.ColumnNumber
             };
         }
+
+        public static Breakpoint Create(
+            FunctionBreakpointDetails breakpointDetails)
+        {
+            return new Breakpoint {
+                Verified = breakpointDetails.Verified,
+                Message = breakpointDetails.Message
+            };
+        }
     }
 }

src/PowerShellEditorServices.Protocol/DebugAdapter/ConfigurationDoneRequest.cs

@@ -0,0 +1,16 @@
+//
+// 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 ConfigurationDoneRequest
+    {
+        public static readonly
+            RequestType<object, object> Type =
+            RequestType<object, object>.Create("configurationDone");
+    }
+}

src/PowerShellEditorServices.Protocol/DebugAdapter/SetFunctionBreakpointsRequest.cs

@@ -0,0 +1,31 @@
+//
+// 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 SetFunctionBreakpointsRequest
+    {
+        public static readonly
+            RequestType<SetFunctionBreakpointsRequestArguments, SetBreakpointsResponseBody> Type =
+            RequestType<SetFunctionBreakpointsRequestArguments, SetBreakpointsResponseBody>.Create("setFunctionBreakpoints");
+    }
+
+    public class SetFunctionBreakpointsRequestArguments
+    {
+        public FunctionBreakpoint[] Breakpoints { get; set; }
+    }
+
+    public class FunctionBreakpoint
+    {
+        /// <summary>
+        /// Gets or sets the name of the function to break on when it is invoked.
+        /// </summary>
+        public string Name { get; set; }
+
+        public string Condition { get; set; }
+    }
+}

src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj

@@ -50,7 +50,9 @@
   <ItemGroup>
     <Compile Include="DebugAdapter\AttachRequest.cs" />
     <Compile Include="DebugAdapter\Breakpoint.cs" />
+    <Compile Include="DebugAdapter\ConfigurationDoneRequest.cs" />
     <Compile Include="DebugAdapter\ContinueRequest.cs" />
+    <Compile Include="DebugAdapter\SetFunctionBreakpointsRequest.cs" />
     <Compile Include="LanguageServer\FindModuleRequest.cs" />
     <Compile Include="LanguageServer\InstallModuleRequest.cs" />
     <Compile Include="MessageProtocol\IMessageSender.cs" />

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -20,6 +20,8 @@ public class DebugAdapter : DebugAdapterBase
     {
         private EditorSession editorSession;
         private OutputDebouncer outputDebouncer;
+        private string scriptPathToLaunch;
+        private string arguments;
 
         public DebugAdapter() : this(new StdioServerChannel())
         {
@@ -42,10 +44,12 @@ protected override void Initialize()
 
             this.SetRequestHandler(LaunchRequest.Type, this.HandleLaunchRequest);
             this.SetRequestHandler(AttachRequest.Type, this.HandleAttachRequest);
+            this.SetRequestHandler(ConfigurationDoneRequest.Type, this.HandleConfigurationDoneRequest);
             this.SetRequestHandler(DisconnectRequest.Type, this.HandleDisconnectRequest);
 
             this.SetRequestHandler(SetBreakpointsRequest.Type, this.HandleSetBreakpointsRequest);
             this.SetRequestHandler(SetExceptionBreakpointsRequest.Type, this.HandleSetExceptionBreakpointsRequest);
+            this.SetRequestHandler(SetFunctionBreakpointsRequest.Type, this.HandleSetFunctionBreakpointsRequest);
 
             this.SetRequestHandler(ContinueRequest.Type, this.HandleContinueRequest);
             this.SetRequestHandler(NextRequest.Type, this.HandleNextRequest);
@@ -110,12 +114,35 @@ protected async Task HandleLaunchRequest(
                 Logger.Write(LogLevel.Verbose, "Script arguments are: " + arguments);
             }
 
+            // NOTE: We don't actually launch the script in response to this
+            // request.  We wait until we receive the configurationDone request
+            // to actually launch the script under the debugger.  This gives
+            // us and VSCode a chance to finish configuring all the types of
+            // breakpoints.
+            this.scriptPathToLaunch = launchParams.Program;
+            this.arguments = arguments;
+
+            await requestContext.SendResult(null);
+        }
+
+        protected Task HandleAttachRequest(
+            AttachRequestArguments attachParams,
+            RequestContext<object> requestContext)
+        {
+            // TODO: Implement this once we support attaching to processes
+            throw new NotImplementedException();
+        }
+
+        protected async Task HandleConfigurationDoneRequest(
+            object args,
+            RequestContext<object> requestContext)
+        {
             // Execute the given PowerShell script and send the response.
             // Note that we aren't waiting for execution to complete here
             // because the debugger could stop while the script executes.
             Task executeTask =
                 editorSession.PowerShellContext
-                    .ExecuteScriptAtPath(launchParams.Program, arguments)
+                    .ExecuteScriptAtPath(this.scriptPathToLaunch, this.arguments)
                     .ContinueWith(
                         async (t) => {
                             Logger.Write(LogLevel.Verbose, "Execution completed, terminating...");
@@ -131,14 +158,6 @@ await requestContext.SendEvent(
             await requestContext.SendResult(null);
         }
 
-        protected Task HandleAttachRequest(
-            AttachRequestArguments attachParams,
-            RequestContext<object> requestContext)
-        {
-            // TODO: Implement this once we support attaching to processes
-            throw new NotImplementedException();
-        }
-
         protected Task HandleDisconnectRequest(
             object disconnectParams,
             RequestContext<object> requestContext)
@@ -198,6 +217,32 @@ await requestContext.SendResult(
                 });
         }
 
+        protected async Task HandleSetFunctionBreakpointsRequest(
+            SetFunctionBreakpointsRequestArguments setBreakpointsParams,
+            RequestContext<SetBreakpointsResponseBody> requestContext)
+        {
+            var breakpointDetails = new FunctionBreakpointDetails[setBreakpointsParams.Breakpoints.Length];
+            for (int i = 0; i < breakpointDetails.Length; i++)
+            {
+                FunctionBreakpoint funcBreakpoint = setBreakpointsParams.Breakpoints[i];
+                breakpointDetails[i] = FunctionBreakpointDetails.Create(
+                    funcBreakpoint.Name,
+                    funcBreakpoint.Condition);
+            }
+
+            FunctionBreakpointDetails[] breakpoints =
+                await editorSession.DebugService.SetFunctionBreakpoints(
+                    breakpointDetails);
+
+            await requestContext.SendResult(
+                new SetBreakpointsResponseBody {
+                    Breakpoints =
+                        breakpoints
+                            .Select(Protocol.DebugAdapter.Breakpoint.Create)
+                            .ToArray()
+                });
+        }
+
         protected async Task HandleSetExceptionBreakpointsRequest(
             SetExceptionBreakpointsRequestArguments setExceptionBreakpointsParams,
             RequestContext<object> requestContext)

src/PowerShellEditorServices.Protocol/Server/DebugAdapterBase.cs

@@ -63,7 +63,9 @@ await requestContext.SendEvent(
             await requestContext.SendResult(
                 new InitializeResponseBody
                 {
+                    SupportsConfigurationDoneRequest = true,
                     SupportsConditionalBreakpoints = true,
+                    SupportsFunctionBreakpoints = true
                 });
         }
     }

src/PowerShellEditorServices/Debugging/BreakpointDetails.cs

@@ -13,20 +13,8 @@ namespace Microsoft.PowerShell.EditorServices
     /// Provides details about a breakpoint that is set in the
     /// PowerShell debugger.
     /// </summary>
-    public class BreakpointDetails
+    public class BreakpointDetails : BreakpointDetailsBase
     {
-        /// <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>
@@ -42,11 +30,6 @@ public class BreakpointDetails
         /// </summary>
         public int? ColumnNumber { get; private set; }
 
-        /// <summary>
-        /// Gets the breakpoint condition string.
-        /// </summary>
-        public string Condition { get; private set; }
-
         private BreakpointDetails()
         {
         }
@@ -91,7 +74,7 @@ public static BreakpointDetails Create(Breakpoint breakpoint)
             if (lineBreakpoint == null)
             {
                 throw new ArgumentException(
-                    "Expected breakpoint type:" + breakpoint.GetType().Name);
+                    "Unexpected breakpoint type: " + breakpoint.GetType().Name);
             }
 
             var breakpointDetails = new BreakpointDetails

src/PowerShellEditorServices/Debugging/BreakpointDetailsBase.cs

@@ -0,0 +1,31 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices
+{
+    /// <summary>
+    /// Provides details about a breakpoint that is set in the
+    /// PowerShell debugger.
+    /// </summary>
+    public abstract class BreakpointDetailsBase
+    {
+        /// <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 breakpoint condition string.
+        /// </summary>
+        public string Condition { get; protected set; }
+    }
+}