Finally get the REPL and completions back

rjmholt · rjmholt · commit 06111c4df766 · 2020-08-28T12:16:24.000-07:00
diff --git a/src/PowerShellEditorServices/Server/PsesLanguageServer.cs b/src/PowerShellEditorServices/Server/PsesLanguageServer.cs
@@ -100,7 +100,7 @@ public async Task StartAsync()
                     .WithHandler<ExpandAliasHandler>()
                     .WithHandler<PsesSemanticTokensHandler>()
                     .OnInitialize(
-                        async (languageServer, request, cancellationToken) =>
+                        (languageServer, request, cancellationToken) =>
                         {
                             IServiceProvider serviceProvider = languageServer.Services;
 
@@ -122,17 +122,7 @@ public async Task StartAsync()
                                 }
                             }
 
-                            // Set the working directory of the PowerShell session to the workspace path
-                            if (workspaceService.WorkspacePath != null
-                                && Directory.Exists(workspaceService.WorkspacePath))
-                            {
-                                await serviceProvider.GetService<PowerShellExecutionService>()
-                                    .ExecutePSCommandAsync(
-                                        new PSCommand().AddCommand("Set-Location").AddParameter("-LiteralPath", workspaceService.WorkspacePath),
-                                        new PowerShellExecutionOptions(),
-                                        cancellationToken)
-                                    .ConfigureAwait(false);
-                            }
+                            return Task.CompletedTask;
                         });
             }).ConfigureAwait(false);
 
diff --git a/src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs b/src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs
@@ -41,18 +41,12 @@ public static IServiceCollection AddPsesLanguageServices(
                 .AddSingleton<TemplateService>()
                 .AddSingleton<EditorOperationsService>()
                 .AddSingleton<RemoteFileManagerService>()
-                .AddSingleton(async (provider) =>
-                    {
-                        var extensionService = new ExtensionService(
-                            provider.GetService<PowerShellExecutionService>(),
-                            provider.GetService<ILanguageServer>());
-
-                        await extensionService.InitializeAsync(
-                            serviceProvider: provider,
-                            editorOperations: provider.GetService<EditorOperationsService>()).ConfigureAwait(false);
-
-                        return extensionService;
-                    })
+                .AddSingleton<ExtensionService>((provider) =>
+                    new ExtensionService(
+                        provider.GetService<ILanguageServer>(),
+                        provider,
+                        provider.GetService<EditorOperationsService>(),
+                        provider.GetService<PowerShellExecutionService>()))
                 .AddSingleton<AnalysisService>();
         }
 
diff --git a/src/PowerShellEditorServices/Services/Extension/ExtensionService.cs b/src/PowerShellEditorServices/Services/Extension/ExtensionService.cs
@@ -59,10 +59,25 @@ internal sealed class ExtensionService
         /// PowerShellContext for loading and executing extension code.
         /// </summary>
         /// <param name="powerShellContext">A PowerShellContext used to execute extension code.</param>
-        internal ExtensionService(PowerShellExecutionService executionService, ILanguageServer languageServer)
+        internal ExtensionService(
+            ILanguageServer languageServer,
+            IServiceProvider serviceProvider,
+            IEditorOperations editorOperations,
+            PowerShellExecutionService executionService)
         {
             ExecutionService = executionService;
             _languageServer = languageServer;
+
+            EditorObject =
+                new EditorObject(
+                    serviceProvider,
+                    this,
+                    editorOperations);
+
+            // Attach to ExtensionService events
+            CommandAdded += ExtensionService_ExtensionAddedAsync;
+            CommandUpdated += ExtensionService_ExtensionUpdatedAsync;
+            CommandRemoved += ExtensionService_ExtensionRemovedAsync;
         }
 
         #endregion
@@ -75,23 +90,10 @@ internal ExtensionService(PowerShellExecutionService executionService, ILanguage
         /// </summary>
         /// <param name="editorOperations">An IEditorOperations implementation.</param>
         /// <returns>A Task that can be awaited for completion.</returns>
-        internal async Task InitializeAsync(
-            IServiceProvider serviceProvider,
-            IEditorOperations editorOperations)
+        internal async Task InitializeAsync()
         {
-            // Attach to ExtensionService events
-            this.CommandAdded += ExtensionService_ExtensionAddedAsync;
-            this.CommandUpdated += ExtensionService_ExtensionUpdatedAsync;
-            this.CommandRemoved += ExtensionService_ExtensionRemovedAsync;
-
-            this.EditorObject =
-                new EditorObject(
-                    serviceProvider,
-                    this,
-                    editorOperations);
-
             // Assign the new EditorObject to be the static instance available to binary APIs
-            this.EditorObject.SetAsStaticInstance();
+            EditorObject.SetAsStaticInstance();
 
             // Register the editor object in the runspace
             await ExecutionService.ExecuteDelegateAsync((pwsh, cancellationToken) =>
diff --git a/src/PowerShellEditorServices/Services/PowerShell/Execution/PipelineThreadExecutor.cs b/src/PowerShellEditorServices/Services/PowerShell/Execution/PipelineThreadExecutor.cs
@@ -60,6 +60,11 @@ public PipelineThreadExecutor(
             _psesHost = psesHost;
             _debugContext = psesHost.DebugContext;
             _readLineProvider = readLineProvider;
+            _consumerThreadCancellationSource = new CancellationTokenSource();
+            _executionQueue = new BlockingCollection<ISynchronousTask>();
+            _loopCancellationContext = new CancellationContext();
+            _commandCancellationContext = new CancellationContext();
+            _taskProcessingLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
 
             _pipelineThread = new Thread(Run)
             {
@@ -75,11 +80,9 @@ public Task<TResult> QueueTask<TResult>(SynchronousTask<TResult> synchronousTask
             _executionQueue.Add(synchronousTask);
             return synchronousTask.Task;
         }
+
         public void Start()
         {
-            // We need to override the idle handler here,
-            // since readline will be overridden by this point
-            _readLineProvider.ReadLine.TryOverrideIdleHandler(OnPowerShellIdle);
             _pipelineThread.Start();
         }
 
@@ -107,6 +110,10 @@ public IDisposable TakeTaskWriterLock()
         private void Run()
         {
             _psesHost.PushInitialPowerShell();
+            // We need to override the idle handler here,
+            // since readline will be overridden when the initial Powershell runspace is instantiated above
+            _readLineProvider.ReadLine.TryOverrideIdleHandler(OnPowerShellIdle);
+            _psesHost.PushNewReplTask();
             RunTopLevelConsumerLoop();
         }
 
diff --git a/src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs b/src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs
@@ -100,7 +100,7 @@ public EditorServicesConsolePSHost(
 
         public override void EnterNestedPrompt()
         {
-            PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested);
+            PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested);
         }
 
         public override void ExitNestedPrompt()
@@ -127,7 +127,7 @@ public void PopRunspace()
         public void PushRunspace(Runspace runspace)
         {
             IsRunspacePushed = true;
-            PushPowerShell(_psFactory.CreatePowerShellForRunspace(runspace), PowerShellFrameType.Remote);
+            PushPowerShellAndRunLoop(_psFactory.CreatePowerShellForRunspace(runspace), PowerShellFrameType.Remote);
         }
 
         public override void SetShouldExit(int exitCode)
@@ -145,7 +145,7 @@ public void PushInitialPowerShell()
 
         internal void PushNonInteractivePowerShell()
         {
-            PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested | PowerShellFrameType.NonInteractive);
+            PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested | PowerShellFrameType.NonInteractive);
         }
 
         internal void CancelCurrentPrompt()
@@ -193,8 +193,6 @@ await ExecutionService.ExecuteDelegateAsync((pwsh, delegateCancellation) =>
             {
                 await SetInitialWorkingDirectoryAsync(hostStartOptions.InitialWorkingDirectory, CancellationToken.None).ConfigureAwait(false);
             }
-
-            _consoleReplRunner?.StartRepl();
         }
 
         private void SetExit()
@@ -212,12 +210,18 @@ private void SetExit()
             }
         }
 
-        private void PushPowerShell(SMA.PowerShell pwsh, PowerShellFrameType frameType)
+        private void PushPowerShellAndRunLoop(SMA.PowerShell pwsh, PowerShellFrameType frameType)
         {
             // TODO: Improve runspace origin detection here
             RunspaceOrigin runspaceOrigin = pwsh.Runspace.RunspaceIsRemote ? RunspaceOrigin.EnteredProcess : RunspaceOrigin.Local;
             var runspaceInfo = RunspaceInfo.CreateFromPowerShell(_logger, pwsh, runspaceOrigin, _localComputerName);
-            PushPowerShell(new PowerShellContextFrame(pwsh, runspaceInfo, frameType));
+            PushPowerShellAndRunLoop(new PowerShellContextFrame(pwsh, runspaceInfo, frameType));
+        }
+
+        private void PushPowerShellAndRunLoop(PowerShellContextFrame frame)
+        {
+            PushPowerShell(frame);
+            _pipelineExecutor.RunPowerShellLoop(frame.FrameType);
         }
 
         private void PushPowerShell(PowerShellContextFrame frame)
@@ -229,8 +233,6 @@ private void PushPowerShell(PowerShellContextFrame frame)
             AddRunspaceEventHandlers(frame.PowerShell.Runspace);
 
             _psFrameStack.Push(frame);
-
-            _pipelineExecutor.RunPowerShellLoop(frame.FrameType);
         }
 
         internal void PopPowerShell()
@@ -271,7 +273,7 @@ private void OnDebuggerStopped(object sender, DebuggerStopEventArgs debuggerStop
             try
             {
                 CurrentPowerShell.WaitForRemoteOutputIfNeeded();
-                PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Debug | PowerShellFrameType.Nested);
+                PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Debug | PowerShellFrameType.Nested);
                 CurrentPowerShell.ResumeRemoteOutputIfNeeded();
             }
             finally
diff --git a/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs b/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs
@@ -17,6 +17,7 @@
 using System.IO;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
+using Microsoft.PowerShell.EditorServices.Services.Extension;
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
@@ -25,22 +26,26 @@ internal class PsesConfigurationHandler : IDidChangeConfigurationHandler
         private readonly ILogger _logger;
         private readonly WorkspaceService _workspaceService;
         private readonly ConfigurationService _configurationService;
+        private readonly ExtensionService _extensionService;
         private readonly EditorServicesConsolePSHost _psesHost;
         private DidChangeConfigurationCapability _capability;
         private bool _profilesLoaded;
         private bool _consoleReplStarted;
+        private bool _extensionServiceInitialized;
         private bool _cwdSet;
 
         public PsesConfigurationHandler(
             ILoggerFactory factory,
             WorkspaceService workspaceService,
             AnalysisService analysisService,
             ConfigurationService configurationService,
+            ExtensionService extensionService,
             EditorServicesConsolePSHost psesHost)
         {
             _logger = factory.CreateLogger<PsesConfigurationHandler>();
             _workspaceService = workspaceService;
             _configurationService = configurationService;
+            _extensionService = extensionService;
             _psesHost = psesHost;
 
             ConfigurationUpdated += analysisService.OnConfigurationUpdated;
@@ -70,6 +75,14 @@ public async Task<Unit> Handle(DidChangeConfigurationParams request, Cancellatio
                 _workspaceService.WorkspacePath,
                 _logger);
 
+            if (!_psesHost.IsRunning)
+            {
+                await _psesHost.StartAsync(new HostStartOptions
+                {
+                    LoadProfiles = _configurationService.CurrentSettings.EnableProfileLoading,
+                }, CancellationToken.None).ConfigureAwait(false);
+            }
+
             if (!this._cwdSet)
             {
                 if (!string.IsNullOrEmpty(_configurationService.CurrentSettings.Cwd)
@@ -90,16 +103,13 @@ await _psesHost.SetInitialWorkingDirectoryAsync(
                 this._cwdSet = true;
             }
 
-            if (!_psesHost.IsRunning)
+            if (!_extensionServiceInitialized)
             {
-                await _psesHost.StartAsync(new HostStartOptions
-                {
-                    LoadProfiles = _configurationService.CurrentSettings.EnableProfileLoading,
-                }, CancellationToken.None).ConfigureAwait(false);
+                await _extensionService.InitializeAsync();
             }
 
             // Run any events subscribed to configuration updates
-            ConfigurationUpdated(this, _configurationService.CurrentSettings);
+            ConfigurationUpdated?.Invoke(this, _configurationService.CurrentSettings);
 
             // Convert the editor file glob patterns into an array for the Workspace
             // Both the files.exclude and search.exclude hash tables look like (glob-text, is-enabled):

Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,11 @@ public PipelineThreadExecutor(`
`60`	`60`	`_psesHost = psesHost;`
`61`	`61`	`_debugContext = psesHost.DebugContext;`
`62`	`62`	`_readLineProvider = readLineProvider;`
	`63`	`+ _consumerThreadCancellationSource = new CancellationTokenSource();`
	`64`	`+ _executionQueue = new BlockingCollection<ISynchronousTask>();`
	`65`	`+ _loopCancellationContext = new CancellationContext();`
	`66`	`+ _commandCancellationContext = new CancellationContext();`
	`67`	`+ _taskProcessingLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);`
`63`	`68`
`64`	`69`	`_pipelineThread = new Thread(Run)`
`65`	`70`	`{`
`@@ -75,11 +80,9 @@ public Task<TResult> QueueTask<TResult>(SynchronousTask<TResult> synchronousTask`
`75`	`80`	`_executionQueue.Add(synchronousTask);`
`76`	`81`	`return synchronousTask.Task;`
`77`	`82`	`}`
	`83`	`+`
`78`	`84`	`public void Start()`
`79`	`85`	`{`
`80`		`- // We need to override the idle handler here,`
`81`		`- // since readline will be overridden by this point`
`82`		`- _readLineProvider.ReadLine.TryOverrideIdleHandler(OnPowerShellIdle);`
`83`	`86`	`_pipelineThread.Start();`
`84`	`87`	`}`
`85`	`88`
`@@ -107,6 +110,10 @@ public IDisposable TakeTaskWriterLock()`
`107`	`110`	`private void Run()`
`108`	`111`	`{`
`109`	`112`	`_psesHost.PushInitialPowerShell();`
	`113`	`+ // We need to override the idle handler here,`
	`114`	`+ // since readline will be overridden when the initial Powershell runspace is instantiated above`
	`115`	`+ _readLineProvider.ReadLine.TryOverrideIdleHandler(OnPowerShellIdle);`
	`116`	`+ _psesHost.PushNewReplTask();`
`110`	`117`	`RunTopLevelConsumerLoop();`
`111`	`118`	`}`
`112`	`119`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ public EditorServicesConsolePSHost(`
`100`	`100`
`101`	`101`	`public override void EnterNestedPrompt()`
`102`	`102`	`{`
`103`		`- PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested);`
	`103`	`+ PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`public override void ExitNestedPrompt()`
`@@ -127,7 +127,7 @@ public void PopRunspace()`
`127`	`127`	`public void PushRunspace(Runspace runspace)`
`128`	`128`	`{`
`129`	`129`	`IsRunspacePushed = true;`
`130`		`- PushPowerShell(_psFactory.CreatePowerShellForRunspace(runspace), PowerShellFrameType.Remote);`
	`130`	`+ PushPowerShellAndRunLoop(_psFactory.CreatePowerShellForRunspace(runspace), PowerShellFrameType.Remote);`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`public override void SetShouldExit(int exitCode)`
`@@ -145,7 +145,7 @@ public void PushInitialPowerShell()`
`145`	`145`
`146`	`146`	`internal void PushNonInteractivePowerShell()`
`147`	`147`	`{`
`148`		`- PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested \| PowerShellFrameType.NonInteractive);`
	`148`	`+ PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Nested \| PowerShellFrameType.NonInteractive);`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`internal void CancelCurrentPrompt()`
`@@ -193,8 +193,6 @@ await ExecutionService.ExecuteDelegateAsync((pwsh, delegateCancellation) =>`
`193`	`193`	`{`
`194`	`194`	`await SetInitialWorkingDirectoryAsync(hostStartOptions.InitialWorkingDirectory, CancellationToken.None).ConfigureAwait(false);`
`195`	`195`	`}`
`196`		`-`
`197`		`- _consoleReplRunner?.StartRepl();`
`198`	`196`	`}`
`199`	`197`
`200`	`198`	`private void SetExit()`
`@@ -212,12 +210,18 @@ private void SetExit()`
`212`	`210`	`}`
`213`	`211`	`}`
`214`	`212`
`215`		`- private void PushPowerShell(SMA.PowerShell pwsh, PowerShellFrameType frameType)`
	`213`	`+ private void PushPowerShellAndRunLoop(SMA.PowerShell pwsh, PowerShellFrameType frameType)`
`216`	`214`	`{`
`217`	`215`	`// TODO: Improve runspace origin detection here`
`218`	`216`	`RunspaceOrigin runspaceOrigin = pwsh.Runspace.RunspaceIsRemote ? RunspaceOrigin.EnteredProcess : RunspaceOrigin.Local;`
`219`	`217`	`var runspaceInfo = RunspaceInfo.CreateFromPowerShell(_logger, pwsh, runspaceOrigin, _localComputerName);`
`220`		`- PushPowerShell(new PowerShellContextFrame(pwsh, runspaceInfo, frameType));`
	`218`	`+ PushPowerShellAndRunLoop(new PowerShellContextFrame(pwsh, runspaceInfo, frameType));`
	`219`	`+ }`
	`220`	`+`
	`221`	`+ private void PushPowerShellAndRunLoop(PowerShellContextFrame frame)`
	`222`	`+ {`
	`223`	`+ PushPowerShell(frame);`
	`224`	`+ _pipelineExecutor.RunPowerShellLoop(frame.FrameType);`
`221`	`225`	`}`
`222`	`226`
`223`	`227`	`private void PushPowerShell(PowerShellContextFrame frame)`
`@@ -229,8 +233,6 @@ private void PushPowerShell(PowerShellContextFrame frame)`
`229`	`233`	`AddRunspaceEventHandlers(frame.PowerShell.Runspace);`
`230`	`234`
`231`	`235`	`_psFrameStack.Push(frame);`
`232`		`-`
`233`		`- _pipelineExecutor.RunPowerShellLoop(frame.FrameType);`
`234`	`236`	`}`
`235`	`237`
`236`	`238`	`internal void PopPowerShell()`
`@@ -271,7 +273,7 @@ private void OnDebuggerStopped(object sender, DebuggerStopEventArgs debuggerStop`
`271`	`273`	`try`
`272`	`274`	`{`
`273`	`275`	`CurrentPowerShell.WaitForRemoteOutputIfNeeded();`
`274`		`- PushPowerShell(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Debug \| PowerShellFrameType.Nested);`
	`276`	`+ PushPowerShellAndRunLoop(_psFactory.CreateNestedPowerShell(CurrentRunspace), PowerShellFrameType.Debug \| PowerShellFrameType.Nested);`
`275`	`277`	`CurrentPowerShell.ResumeRemoteOutputIfNeeded();`
`276`	`278`	`}`
`277`	`279`	`finally`