Merge PS context into execution service, make REPL service a subcomponent

Author: rjmholt

ex.js

@@ -0,0 +1,13 @@
+function run(timeout, count) {
+  let i = 0;
+  function inner() {
+    if (i === count) {
+      return;
+    }
+    console.log(i);
+    i++;
+    setTimeout(inner, timeout);
+  }
+  inner();
+}
+

src/PowerShellEditorServices/Server/PsesLanguageServer.cs

@@ -102,8 +102,6 @@ public async Task StartAsync()
                         {
                             IServiceProvider serviceProvider = languageServer.Services;
 
-                            serviceProvider.GetService<PowerShellConsoleService>().StartRepl();
-
                             var workspaceService = serviceProvider.GetService<WorkspaceService>();
 
                             // Grab the workspace path from the parameters

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

@@ -29,10 +29,6 @@ public static IServiceCollection AddPsesLanguageServices(
                         provider.GetService<ILoggerFactory>(),
                         provider.GetService<ILanguageServer>(),
                         hostStartupInfo))
-                .AddSingleton<PowerShellConsoleService>(
-                    (provider) => PowerShellConsoleService.CreateAndStart(
-                        provider.GetService<ILoggerFactory>(),
-                        provider.GetService<PowerShellExecutionService>()))
                 .AddSingleton<TemplateService>()
                 .AddSingleton<EditorOperationsService>()
                 .AddSingleton<RemoteFileManagerService>()

src/PowerShellEditorServices/Services/PowerShell/Console/ConsoleReadLine.cs

@@ -3,16 +3,13 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using System.Collections.ObjectModel;
-using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
     using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
-    using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
     using System;
     using System.Collections.Generic;
     using System.Management.Automation;

src/PowerShellEditorServices/Services/PowerShell/PowerShellConsoleService.cs renamed to src/PowerShellEditorServices/Services/PowerShell/Console/ConsoleReplRunner.cs

@@ -1,46 +1,25 @@
 using Microsoft.Extensions.Logging;
-using Microsoft.PowerShell.EditorServices.Services.PowerShell.Console;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility;
-using Microsoft.PowerShell.EditorServices.Utility;
+using PowerShellEditorServices.Services.PowerShell.Utility;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-using System.Reflection;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Microsoft.PowerShell.EditorServices.Services.PowerShell
+namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console
 {
-    internal class PowerShellConsoleService : IDisposable
+    internal class ConsoleReplRunner : IDisposable
     {
-        public static PowerShellConsoleService CreateAndStart(
-            ILoggerFactory loggerFactory,
-            PowerShellExecutionService executionService)
-        {
-            return new PowerShellConsoleService(
-                loggerFactory,
-                executionService,
-                executionService.EditorServicesHost,
-                executionService.ReadLine,
-                executionService.PSReadLineProxy);
-        }
-
         private readonly ILogger _logger;
 
         private readonly PowerShellExecutionService _executionService;
 
-        private readonly EditorServicesConsolePSHost _editorServicesHost;
-
-        private readonly ConsoleReadLine _readLine;
-
-        private readonly PSReadLineProxy _psrlProxy;
-
         private readonly ConcurrentStack<ReplTask> _replLoopTaskStack;
 
         // This is required because PSRL will keep prompting for keys as we push a new REPL task
@@ -52,35 +31,23 @@ public static PowerShellConsoleService CreateAndStart(
 
         private bool _exiting;
 
-        private bool _debugging;
-
-        private PowerShellConsoleService(
+        public ConsoleReplRunner(
             ILoggerFactory loggerFactory,
-            PowerShellExecutionService executionService,
-            EditorServicesConsolePSHost editorServicesHost,
-            ConsoleReadLine readLine,
-            PSReadLineProxy psrlProxy)
+            PowerShellExecutionService executionService)
         {
-            _logger = loggerFactory.CreateLogger<PowerShellConsoleService>();
+            _logger = loggerFactory.CreateLogger<ConsoleReplRunner>();
             _replLoopTaskStack = new ConcurrentStack<ReplTask>();
             _commandCancellationStack = new ConcurrentStack<CommandCancellation>();
             _executionService = executionService;
-            _editorServicesHost = editorServicesHost;
-            _readLine = readLine;
-            _psrlProxy = psrlProxy;
             _exiting = false;
-            _debugging = false;
         }
 
         public void StartRepl()
         {
             System.Console.CancelKeyPress += OnCancelKeyPress;
             System.Console.InputEncoding = Encoding.UTF8;
             System.Console.OutputEncoding = Encoding.UTF8;
-            _psrlProxy.OverrideReadKey(ReadKey);
-            _executionService.PowerShellPushed += OnPowerShellPushed;
-            _executionService.PromptCancellationRequested += OnPromptCancellationRequested;
-            _executionService.FrameExiting += OnFrameExiting;
+            _executionService.PSReadLineProxy.OverrideReadKey(ReadKey);
             PushNewReplTask();
         }
 
@@ -92,9 +59,6 @@ public void Dispose()
             }
 
             System.Console.CancelKeyPress -= OnCancelKeyPress;
-            _executionService.PowerShellPushed -= OnPowerShellPushed;
-            _executionService.PromptCancellationRequested -= OnPromptCancellationRequested;
-            _executionService.FrameExiting -= OnFrameExiting;
         }
 
         public void CancelCurrentPrompt()
@@ -149,7 +113,7 @@ private async Task RunReplLoopAsync()
                             if (currentCommandCancellation.CancellationSource.IsCancellationRequested
                                 || LastKeyWasCtrlC())
                             {
-                                _editorServicesHost.UI.WriteLine();
+                                _executionService.EditorServicesHost.UI.WriteLine();
                             }
                             continue;
                         }
@@ -190,9 +154,9 @@ private async Task<string> GetPromptStringAsync(CancellationToken cancellationTo
         {
             string prompt = (await GetPromptOutputAsync(cancellationToken).ConfigureAwait(false)).FirstOrDefault() ?? "PS> ";
 
-            if (_editorServicesHost.Runspace.RunspaceIsRemote)
+            if (_executionService.EditorServicesHost.Runspace.RunspaceIsRemote)
             {
-                prompt = _editorServicesHost.Runspace.GetRemotePrompt(prompt);
+                prompt = _executionService.EditorServicesHost.Runspace.GetRemotePrompt(prompt);
             }
 
             return prompt;
@@ -210,12 +174,12 @@ private Task<IReadOnlyList<string>> GetPromptOutputAsync(CancellationToken cance
 
         private void WritePrompt(string promptString)
         {
-            _editorServicesHost.UI.Write(promptString);
+            _executionService.EditorServicesHost.UI.Write(promptString);
         }
 
         private Task<string> InvokeReadLineAsync(CancellationToken cancellationToken)
         {
-            return _readLine.ReadCommandLineAsync(cancellationToken);
+            return _executionService.ReadLine.ReadCommandLineAsync(cancellationToken);
         }
 
         private Task InvokeInputAsync(string input, CancellationToken cancellationToken)
@@ -230,30 +194,17 @@ private Task InvokeInputAsync(string input, CancellationToken cancellationToken)
             return _executionService.ExecutePSCommandAsync(command, executionOptions, cancellationToken);
         }
 
-        private void OnCancelKeyPress(object sender, ConsoleCancelEventArgs args)
-        {
-            CancelCurrentPrompt();
-        }
-
-        private void OnPowerShellPushed(object sender, PowerShellPushedArgs args)
+        public void SetReplPop()
         {
-            if ((args.FrameType & PowerShellFrameType.NonInteractive) == 0)
-            {
-                PushNewReplTask();
-            }
+            _exiting = true;
+            StopCurrentRepl();
         }
 
-        private void OnPromptCancellationRequested(object sender, PromptCancellationRequestedArgs args)
+        private void OnCancelKeyPress(object sender, ConsoleCancelEventArgs args)
         {
             CancelCurrentPrompt();
         }
 
-        private void OnFrameExiting(object sender, FrameExitingArgs args)
-        {
-            _exiting = true;
-            StopCurrentRepl();
-        }
-
         private void OnReplCanceled()
         {
             // Ordinarily, when the REPL is canceled
@@ -293,12 +244,11 @@ private bool LastKeyWasCtrlC()
                 && (_lastKey.Value.Modifiers & ConsoleModifiers.Alt) == 0;
         }
 
-        private void PushNewReplTask()
+        public void PushNewReplTask()
         {
             ReplTask.PushAndStart(_replLoopTaskStack, RunReplLoopAsync, OnReplCanceled);
         }
 
-
         private class ReplTask
         {
             public static void PushAndStart(

src/PowerShellEditorServices/Services/PowerShell/Execution/DebuggerResumingEventArgs.cs

@@ -0,0 +1,15 @@
+using System.Management.Automation;
+
+namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution
+{
+    internal class DebuggerResumingEventArgs
+    {
+        public DebuggerResumingEventArgs(DebuggerResumeAction resumeAction)
+        {
+            ResumeAction = resumeAction;
+        }
+
+        public DebuggerResumeAction ResumeAction { get; }
+
+    }
+}