Add choice prompt handling for PSHostUserInterface

This change adds a general solution for handling the PromptForChoice
method in our PSHostUserInterface implementation.  It abstracts the
display and response handling for prompts so that different prompt
interfaces can be used in different contexts, all within the same session.

The initial implementation includes a console-based prompt handler which
operates much like the standard prompt display in the PowerShell console.
Another implementation is provided which sends an event through the JSON
protocol so that an editor client can display the prompt in an
appropriate user interface.

Resolves #85.

Author: daviwil

src/PowerShellEditorServices.Protocol/Messages/PromptEvents.cs

@@ -0,0 +1,36 @@
+//
+// 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.Messages
+{
+    public class ShowChoicePromptNotification
+    {
+        public static readonly
+            EventType<ShowChoicePromptNotification> Type =
+            EventType<ShowChoicePromptNotification>.Create("powerShell/showChoicePrompt");
+
+        public string Caption { get; set; }
+
+        public string Message { get; set; }
+
+        public ChoiceDetails[] Choices { get; set; }
+
+        public int DefaultChoice { get; set; }
+    }
+
+    public class CompleteChoicePromptNotification
+    {
+        public static readonly
+            EventType<CompleteChoicePromptNotification> Type =
+            EventType<CompleteChoicePromptNotification>.Create("powerShell/completeChoicePrompt");
+
+        public bool PromptCancelled { get; set; }
+
+        public string ChosenItem { get; set; }
+    }
+}
+

src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj

@@ -64,6 +64,7 @@
     <Compile Include="DebugAdapter\AttachRequest.cs" />
     <Compile Include="DebugAdapter\Breakpoint.cs" />
     <Compile Include="DebugAdapter\ContinueRequest.cs" />
+    <Compile Include="Messages\PromptEvents.cs" />
     <Compile Include="Server\DebugAdapter.cs" />
     <Compile Include="Server\DebugAdapterBase.cs" />
     <Compile Include="Client\DebugAdapterClientBase.cs" />
@@ -101,6 +102,7 @@
     <Compile Include="LanguageServer\ExpandAliasRequest.cs" />
     <Compile Include="LanguageServer\Hover.cs" />
     <Compile Include="Client\LanguageClientBase.cs" />
+    <Compile Include="Server\IEventWriter.cs" />
     <Compile Include="Server\LanguageServer.cs" />
     <Compile Include="Server\LanguageServerBase.cs" />
     <Compile Include="LanguageServer\ShowOnlineHelpRequest.cs" />
@@ -132,6 +134,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="LanguageServer\References.cs" />
     <Compile Include="Server\LanguageServerSettings.cs" />
+    <Compile Include="Server\PromptHandlers.cs" />
     <Compile Include="Server\ProtocolServer.cs" />
   </ItemGroup>
   <ItemGroup>

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -29,7 +29,7 @@ public DebugAdapter(ChannelBase serverChannel) : base(serverChannel)
             this.editorSession = new EditorSession();
             this.editorSession.StartSession();
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
-            this.editorSession.PowerShellContext.OutputWritten += this.powerShellContext_OutputWritten;
+            this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
         }
 
         protected override void Initialize()
@@ -312,27 +312,37 @@ protected async Task HandleEvaluateRequest(
             EvaluateRequestArguments evaluateParams,
             RequestContext<EvaluateResponseBody> requestContext)
         {
+            string valueString = null;
+            int variableId = 0;
+
             bool isFromRepl =
                 string.Equals(
                     evaluateParams.Context,
                     "repl",
                     StringComparison.InvariantCultureIgnoreCase);
 
-            VariableDetails result =
-                await editorSession.DebugService.EvaluateExpression(
+            if (isFromRepl)
+            {
+                // Send the input through the console service
+                editorSession.ConsoleService.ReceiveInputString(
                     evaluateParams.Expression,
-                    evaluateParams.FrameId,
-                    isFromRepl);
-
-            string valueString = null;
-            int variableId = 0;
-
-            if (result != null)
+                    false);
+            }
+            else
             {
-                valueString = result.ValueString;
-                variableId =
-                    result.IsExpandable ?
-                        result.Id : 0;
+                VariableDetails result =
+                    await editorSession.DebugService.EvaluateExpression(
+                        evaluateParams.Expression,
+                        evaluateParams.FrameId,
+                        isFromRepl);
+
+                if (result != null)
+                {
+                    valueString = result.ValueString;
+                    variableId =
+                        result.IsExpandable ?
+                            result.Id : 0;
+                }
             }
 
             await requestContext.SendResult(

src/PowerShellEditorServices.Protocol/Server/IEventWriter.cs

@@ -0,0 +1,18 @@
+//
+// 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;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.Server
+{
+    internal interface IEventWriter
+    {
+        Task SendEvent<TParams>(
+            EventType<TParams> eventType,
+            TParams eventParams);
+    }
+}
+

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -6,22 +6,22 @@
 using Microsoft.PowerShell.EditorServices.Protocol.LanguageServer;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
+using Microsoft.PowerShell.EditorServices.Protocol.Messages;
 using Microsoft.PowerShell.EditorServices.Utility;
 using Nito.AsyncEx;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Management.Automation;
-using System.Management.Automation.Language;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using DebugAdapterMessages = Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter;
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.Server
 {
-    public class LanguageServer : LanguageServerBase 
+    public class LanguageServer : LanguageServerBase, IEventWriter
     {
         private static CancellationTokenSource existingRequestCancellation;
 
@@ -36,7 +36,13 @@ public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
         {
             this.editorSession = new EditorSession();
             this.editorSession.StartSession();
-            this.editorSession.PowerShellContext.OutputWritten += this.powerShellContext_OutputWritten;
+            this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+
+            // Always send console prompts through the UI in the language service
+            // TODO: This will change later once we have a general REPL available
+            // in VS Code.
+            this.editorSession.ConsoleService.PushPromptHandlerContext(
+                new ProtocolPromptHandlerContext(this));
         }
 
         protected override void Initialize()
@@ -62,6 +68,7 @@ protected override void Initialize()
 
             this.SetRequestHandler(ShowOnlineHelpRequest.Type, this.HandleShowOnlineHelpRequest);
             this.SetRequestHandler(ExpandAliasRequest.Type, this.HandleExpandAliasRequest);
+            this.SetEventHandler(CompleteChoicePromptNotification.Type, this.HandleCompleteChoicePromptNotification);
 
             this.SetRequestHandler(DebugAdapterMessages.EvaluateRequest.Type, this.HandleEvaluateRequest);
         }
@@ -166,6 +173,25 @@ Sort Start -Descending
             await requestContext.SendResult(result.First().ToString());
         }
 
+        protected Task HandleCompleteChoicePromptNotification(
+            CompleteChoicePromptNotification completeChoicePromptParams,
+            EventContext eventContext)
+        {
+            if (!completeChoicePromptParams.PromptCancelled)
+            {
+                this.editorSession.ConsoleService.ReceiveInputString(
+                    completeChoicePromptParams.ChosenItem,
+                    false);
+            }
+            else
+            {
+                // Cancel the current prompt
+                this.editorSession.ConsoleService.SendControlC();
+            }
+
+            return Task.FromResult(true);
+        }
+
         protected Task HandleDidOpenTextDocumentNotification(
             DidOpenTextDocumentNotification openParams,
             EventContext eventContext)
@@ -676,11 +702,15 @@ protected async Task HandleEvaluateRequest(
             DebugAdapterMessages.EvaluateRequestArguments evaluateParams,
             RequestContext<DebugAdapterMessages.EvaluateResponseBody> requestContext)
         {
-            var results = 
-                await this.editorSession.PowerShellContext.ExecuteScriptString(
+            // We don't await the result of the execution here because we want
+            // to be able to receive further messages while the current script
+            // is executing.  This important in cases where the pipeline thread
+            // gets blocked by something in the script like a prompt to the user.
+            var executeTask =
+                this.editorSession.PowerShellContext.ExecuteScriptString(
                     evaluateParams.Expression,
                     true,
-                    true);
+                    true).ConfigureAwait(false);
 
             // Return an empty result since the result value is irrelevant
             // for this request in the LanguageServer

src/PowerShellEditorServices.Protocol/Server/PromptHandlers.cs

@@ -0,0 +1,49 @@
+//
+// 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.Console;
+using Microsoft.PowerShell.EditorServices.Protocol.Messages;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.Server
+{
+    internal class ProtocolPromptHandlerContext : IPromptHandlerContext
+    {
+        private IEventWriter eventWriter;
+
+        public ProtocolPromptHandlerContext(IEventWriter eventWriter)
+        {
+            this.eventWriter = eventWriter;
+        }
+
+        public ChoicePromptHandler GetChoicePromptHandler()
+        {
+            return new ProtocolChoicePromptHandler(this.eventWriter);
+        }
+    }
+
+    internal class ProtocolChoicePromptHandler : ChoicePromptHandler
+    {
+        private IEventWriter eventWriter;
+
+        public ProtocolChoicePromptHandler(IEventWriter eventWriter)
+        {
+            this.eventWriter = eventWriter;
+        }
+
+        protected override void ShowPrompt(PromptStyle promptStyle)
+        {
+            eventWriter.SendEvent(
+                ShowChoicePromptNotification.Type,
+                new ShowChoicePromptNotification
+                {
+                    Caption = this.Caption,
+                    Message = this.Message,
+                    Choices = this.Choices,
+                    DefaultChoice = this.DefaultChoice
+                }).ConfigureAwait(false);
+        }
+    }
+}
+

src/PowerShellEditorServices.Protocol/Server/ProtocolServer.cs

@@ -5,7 +5,6 @@
 
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
-using Newtonsoft.Json.Linq;
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -110,15 +109,19 @@ public Task SendEvent<TParams>(
 
             if (!this.serverChannel.MessageDispatcher.InMessageLoopThread)
             {
+                TaskCompletionSource<bool> writeTask = new TaskCompletionSource<bool>();
+
                 this.serverChannel.MessageDispatcher.SynchronizationContext.Post(
                     async (obj) =>
                     {
                         await this.serverChannel.MessageWriter.WriteEvent(
                             eventType,
                             eventParams);
+
+                        writeTask.SetResult(true);
                     }, null);
 
-                return Task.FromResult(true);
+                return writeTask.Task;
             }
             else
             {