Reimplement the way PowerShell is run and hosted in PSES with a dedicated pipeline thread consumer #1459

rjmholt · 2021-04-23T23:52:43Z

andyleejordan

I got through the files we reviewed over-the-shoulder, we need to continue for the rest still.

andyleejordan · 2021-04-23T23:54:04Z

src/PowerShellEditorServices.Hosting/Commands/StartEditorServicesCommand.cs

@@ -38,7 +38,7 @@ namespace Microsoft.PowerShell.EditorServices.Commands
    public sealed class StartEditorServicesCommand : PSCmdlet
    {
        // TODO: Remove this when we drop support for PS6.
-        private static bool s_isWindows =
+        private readonly static bool s_isWindows =


Pull into new PR.

andyleejordan · 2021-04-23T23:55:24Z

src/PowerShellEditorServices.Hosting/Internal/EditorServicesRunner.cs

@@ -77,7 +77,7 @@ private async Task CreateEditorServicesAndRunUntilShutdown()
                _logger.Log(PsesLogLevel.Diagnostic, "Creating/running editor services");

                bool creatingLanguageServer = _config.LanguageServiceTransport != null;
-                bool creatingDebugServer = _config.DebugServiceTransport != null;
+                bool creatingDebugServer = false;// _config.DebugServiceTransport != null;


TODO Debugging

andyleejordan · 2021-04-23T23:56:44Z

src/PowerShellEditorServices.Hosting/Configuration/HostLogger.cs

-            _writerThread = new Thread(RunWriter);
+            _writerThread = new Thread(RunWriter)
+            {
+                Name = "PSES Stream Logger Thread"


Pull into new PR.

andyleejordan · 2021-04-24T00:48:16Z

src/PowerShellEditorServices.Hosting/Configuration/HostLogger.cs

@@ -308,6 +311,8 @@ public void OnCompleted()
            _fileWriter.Flush();
            _fileWriter.Close();
            _fileWriter.Dispose();
+            _cancellationSource.Dispose();
+            _messageQueue.Dispose();


Is this a bug in our existing code?

andyleejordan · 2021-04-24T00:49:01Z

src/PowerShellEditorServices/PowerShellEditorServices.csproj

+    <Compile Remove="Services\Extension\Templating\**" />
+    <Compile Remove="Services\PowerShellContext\**\*.cs" />
+    <EmbeddedResource Remove="Services\Extension\Templating\**" />
+    <None Remove="Services\Extension\Templating\**" />


Let's not forget to delete all this code 🤣

andyleejordan · 2021-04-26T20:10:50Z

src/PowerShellEditorServices/Services/DebugAdapter/Debugging/DebuggerStoppedEventArgs.cs

@@ -28,7 +29,7 @@ internal class DebuggerStoppedEventArgs
        /// </summary>
        public bool IsRemoteSession
        {
-            get { return this.RunspaceDetails.Location == RunspaceLocation.Remote; }
+            get => RunspaceInfo.RunspaceOrigin != RunspaceOrigin.Local;


Would love to apply some tool to automatically fix this kind of thing in the rest of our codebase too.

andyleejordan · 2021-04-26T20:11:50Z

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs

                }
-                debugRunspaceCmd = $"\nDebug-Runspace -Name '{request.RunspaceName}'";
+
+                // TODO: We have the ID, why not just use that?


andyleejordan · 2021-04-26T20:11:59Z

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs

                foreach (var id in ids)
                {
                    _debugStateService.RunspaceId = id;
                    break;
+
+                    // TODO: If we don't end up setting this, we should throw


andyleejordan · 2021-04-26T20:13:55Z

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

+using System.Collections.Generic;
+using System.Text;
+
+namespace PowerShellEditorServices.Services.PowerShell.Console


TODO: Explain (in comments in the code) why we need this (I remember an explanation from our code review but don't want to get it wrong here)

Suggested change

namespace PowerShellEditorServices.Services.PowerShell.Console

namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console

andyleejordan · 2021-04-26T20:15:13Z

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

+                }}
+
+                Import-Module -ModuleInfo $module
+                return [Microsoft.PowerShell.PSConsoleReadLine]


We should both stop supporting loading any arbitrary PSReadLine in and only support what we ship, and ideally we should also pull it in as a .NET dependency instead of a PowerShell module (though that comes with its own complications).

/cc @daxian-dbw

andyleejordan · 2021-05-04T19:38:44Z

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

+using System.Collections.Generic;
+using System.Text;
+
+namespace PowerShellEditorServices.Services.PowerShell.Console


Suggested change

namespace PowerShellEditorServices.Services.PowerShell.Console

namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Console

andyleejordan · 2021-05-04T19:50:14Z

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

+            }
+            catch (OperationCanceledException)
+            {
+                return new ConsoleKeyInfo(


Warning: super hacky "nulled" ConsoleKeyInfo. Use a space because it renders unseeable to a human, and ConsoleKey.DownArrow doesn't do anything for the console when it's empty.

May be worthwhile to experiment with throwing OperationCanceledException or own exception.

andyleejordan · 2021-05-04T19:56:29Z

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

+                    }
+                    else if (keyInfo.Key == ConsoleKey.Tab && isCommandLine)
+                    {
+                        /*


TODO: Delete this.

andyleejordan · 2021-05-04T20:07:17Z

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

+                }}
+
+                Import-Module -ModuleInfo $module
+                return [Microsoft.PowerShell.PSConsoleReadLine]


We should both stop supporting loading any arbitrary PSReadLine in and only support what we ship, and ideally we should also pull it in as a .NET dependency instead of a PowerShell module (though that comes with its own complications).

andyleejordan · 2021-05-04T20:14:39Z

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

+        {
+            // Switch between long and short wait periods depending on if the
+            // user has recently (last 5 seconds) pressed a key to avoid preventing
+            // the CPU from entering low power mode.


andyleejordan · 2021-05-04T20:16:02Z

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

+            // this we use the UnixConsoleEcho package to disable echo prior to waiting.
+            if (VersionUtils.IsPS6)
+            {
+                InputEcho.Disable();


This has been fixed in PowerShell 7 because .NET 3.1 fixed it, hence we can remove this code now.

andyleejordan · 2021-05-04T20:28:00Z

src/PowerShellEditorServices/Services/PowerShell/Debugging/DscBreakpointCapability.cs

+                try
+                {
+                    dscModule = pwsh.AddCommand("Import-Module")
+                        .AddArgument(@"C:\Program Files\DesiredStateConfiguration\1.0.0.0\Modules\PSDesiredStateConfiguration\PSDesiredStateConfiguration.psd1")


@anmenaga do you know if this is how we should be looking for DSC?

For 2 recent versions (v2.0.5 and v3) of DSC running in PS Core - I would rely on PSModulePath (Get-Module -Name PSDesiredStateConfiguration -ListAvailable)
But there is code above in this method that says "DSC support is enabled only for Windows PowerShell.".
In Windows PowerShell days it was quite possible to rely that module is in specific folder in Program Files.

andyleejordan · 2021-05-04T20:30:08Z

src/PowerShellEditorServices/Services/PowerShell/Debugging/PowerShellDebugContext.cs

+
+        private void RaiseDebuggerStoppedEvent()
+        {
+            // TODO: Send language server message to start debugger


TODO: Debugger.

rjmholt · 2021-04-28T17:36:09Z

ex.js

@@ -0,0 +1,13 @@
+function run(timeout, count) {


Delete this file

rjmholt · 2021-04-28T17:36:21Z

integrated.sln

@@ -0,0 +1,153 @@
+


We won't need this after

rjmholt · 2021-05-10T20:38:33Z

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs

+
+        public override void NotifyBeginApplication()
+        {
+            // TODO: Work out what to do here


https://docs.microsoft.com/en-us/dotnet/api/system.management.automation.host.pshost.notifybeginapplication

rjmholt · 2021-05-10T20:59:16Z

src/PowerShellEditorServices/Services/Symbols/Vistors/AstOperations.cs

+            // CommandCompletion.CompleteInput because PSReadLine won't be taking up the
+            // main runspace.
+            /*
+            if (powerShellContext.IsCurrentRunspaceOutOfProcess())


Our new mechanism actually means we can just always do this

dkattan · 2021-06-06T17:03:08Z

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

+            _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);


ReadLine is null here in my testing, causing a NullReferenceException. _readLineProvider is not null. I changed this to _readLineProvider.ReadLine?.TryOverrideIdleHandler(OnPowerShellIdle); and it worked as expected.

dkattan · 2021-06-06T17:10:55Z

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs

+
+        internal CancellationTokenSource CurrentCancellationSource => CurrentFrame.CancellationTokenSource;
+
+        private PowerShellContextFrame CurrentFrame => _psFrameStack.Peek();


Peek() throws an exception when _psFrameStack.Count == 0. When initializing from the MonacoLanguageClient, the _psFrameStack.Count == 0 until the workspace/didChangeConfiguration method is called.

To Workaround this, I changed this line to

private PowerShellContextFrame CurrentFrame => _psFrameStack.Count > 0 ? _psFrameStack.Peek() : null;

dkattan · 2021-06-06T17:12:06Z

src/PowerShellEditorServices/Services/PowerShell/Host/EditorServicesConsolePSHost.cs

+
+        internal SMA.PowerShell CurrentPowerShell => CurrentFrame.PowerShell;
+
+        internal RunspaceInfo CurrentRunspace => CurrentFrame.RunspaceInfo;


internal RunspaceInfo CurrentRunspace => CurrentFrame?.RunspaceInfo;

This needs to be done in addition to the change below to prevent the null reference that would occur after returning null instead of allowing Peek() to throw an exception.

dkattan · 2021-06-06T17:16:38Z

src/PowerShellEditorServices/Services/Symbols/Vistors/AstOperations.cs

+                    options: null,
+                    powershell: pwsh);
+            }, representation: "CompleteInput", cancellationToken);
+


Consider adding the following to allow any underlying exceptions to bubble up:

if(pwsh.HadErrors) { throw pwsh.InvocationStateInfo.Reason.GetBaseException(); }

andyleejordan

Great progress! Let's pick back up tomorrow and try to plow through the other half of the files.

andyleejordan · 2021-09-29T21:12:26Z

src/PowerShellEditorServices/Server/PsesLanguageServer.cs

@@ -108,11 +114,12 @@ public async Task StartAsync()
                    // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialize
                    .OnInitialize(
                        // TODO: Either fix or ignore "method lacks 'await'" warning.


Well now we can delete the comment too!

andyleejordan · 2021-09-29T21:14:24Z

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

                .AddSingleton<EditorOperationsService>()
                .AddSingleton<RemoteFileManagerService>()
-                .AddSingleton<ExtensionService>(
-                    (provider) =>
+                .AddSingleton<ExtensionService>((provider) =>
                    {
                        var extensionService = new ExtensionService(


TODO: Add note that this is thing for $psEditor and that we'll clean it up later PowerShell/vscode-powershell#3563

andyleejordan · 2021-09-29T21:18:12Z

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

@@ -17,33 +24,31 @@ internal static class PsesServiceCollectionExtensions
            this IServiceCollection collection,
            HostStartupInfo hostStartupInfo)
        {
-            return collection.AddSingleton<WorkspaceService>()
+            return collection
+                .AddSingleton<HostStartupInfo>(hostStartupInfo)


Awesome, replaces the weird way we were passing this to PowerShellContextService

andyleejordan · 2021-09-29T21:19:49Z

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

+                .AddSingleton<EditorServicesConsolePSHost>()
+                .AddSingleton<IRunspaceContext>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>())
+                .AddSingleton<PowerShellExecutionService>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>().ExecutionService)
                .AddSingleton<ConfigurationService>()
-                .AddSingleton<PowerShellContextService>(
-                    (provider) =>
-                        PowerShellContextService.Create(
-                            provider.GetService<ILoggerFactory>(),
-                            // NOTE: Giving the context service access to the language server this
-                            // early is dangerous because it allows it to start sending
-                            // notifications etc. before it has initialized, potentially resulting
-                            // in deadlocks. We're working on a solution to this.
-                            provider.GetService<OmniSharp.Extensions.LanguageServer.Protocol.Server.ILanguageServerFacade>(),
-                            hostStartupInfo))
-                .AddSingleton<TemplateService>() // TODO: What's the difference between this and the TemplateHandler?
+                .AddSingleton<IPowerShellDebugContext>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>().DebugContext)


This was refactored in incoming PRs, and so this is just temporary glue from when the separation of the host and the execution stuff was tried (and didn't work).

@rjmholt if you could elaborate a little bit on your experience. Doesn't need to be here, but somewhere.

andyleejordan · 2021-09-29T21:25:58Z

src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs

@@ -301,7 +308,7 @@ public async Task RemoveBreakpointsAsync(IEnumerable<Breakpoint> breakpoints)
                psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");
                psCommand.AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());

-                await _powerShellContextService.ExecuteCommandAsync<object>(psCommand);
+                await _executionService.ExecutePSCommandAsync<object>(psCommand, new PowerShellExecutionOptions(), CancellationToken.None);


Note that the repetition of new PowerShellExecutionOptions() was cleaned up in a later PR, and also note that we can make the default cancellation token CancellationToken.None.

andyleejordan · 2021-09-29T22:25:11Z

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

+            DebuggerCommandResults debuggerResult = null;
+            try
+            {
+                debuggerResult = _pwsh.Runspace.Debugger.ProcessCommand(_psCommand, outputCollection);


Some documentation / context around how this works would be good.

andyleejordan · 2021-09-29T22:30:08Z

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

+        {
+            cancellationToken.Register(CancelDebugExecution);
+
+            var outputCollection = new PSDataCollection<PSObject>();


Super weird workaround we're copying from PowerShell etc. because ProcessCommand (the debugger's command invoker) doesn't support Out-String (which is what we would otherwise use like in InvokeCommand for ExecuteNormally.

andyleejordan · 2021-09-29T22:35:04Z

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

+
+                _pwsh.InvokeCommand(command);
+            }
+            finally


This method purposefully doesn't catch every exception. It's an implementation of an abstract class which catches the thrown exceptions and sets the exception on the task completion source. So they're bubbled up.

andyleejordan · 2021-09-29T22:51:08Z

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

+{
+    public class ExecutionCanceledException : Exception
+    {
+        public ExecutionCanceledException(string message, Exception innerException)


Double check that this is used.

andyleejordan · 2021-09-29T23:03:54Z

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

+
+            }
+
+            // TODO: Run nested pipeline here for engine event handling


Working in another topic branch.

andyleejordan

One more round!

andyleejordan · 2021-09-30T17:50:33Z

src/PowerShellEditorServices/Services/PowerShell/Handlers/EvaluateHandler.cs

+        public Task<EvaluateResponseBody> Handle(EvaluateRequestArguments request, CancellationToken cancellationToken)
+        {
+            _executionService.ExecutePSCommandAsync(
+                new PSCommand().AddScript(request.Expression),
+                new PowerShellExecutionOptions { WriteInputToHost = true, WriteOutputToHost = true, AddToHistory = true, InterruptCommandPrompt = true },
+                CancellationToken.None);
+
+            return Task.FromResult(new EvaluateResponseBody
+            {
+                Result = "",
+                VariablesReference = 0
+            });
+        }


I'm definitely curious why we fake the task instead of returning the actual task created by executing the command asynchronously. Presumably O# is waiting on this handler to complete and indicate that the request (which we think amounts to F8) has been run.

Also curious about ignoring the passed in cancellation token.

@TylerLeonhardt @SeeminglyScience @rkeithhill in case any of you know why we don't await the result from the evaluate handler... I have an inkling it was due to some kind of deadlock issue?

My guess is that it's because an evaluation can spawn more messages like the psEditor API, debugging, the "running" status messages, etc. Assuming message processing isn't done on a single thread anymore it may be safe to await that now.

A good test would be to put something like this in an editor pane:

$psEditor.GetEditorContext().CurrentFile.InsertText('testing')

and eval that line. See if it deadlocks.

andyleejordan · 2021-09-30T17:57:56Z

src/PowerShellEditorServices/Services/PowerShell/Handlers/GetVersionHandler.cs

+                        new PowerShellExecutionOptions { WriteInputToHost = true, WriteOutputToHost = true, AddToHistory = true },
+                        CancellationToken.None).ConfigureAwait(false);
+
+                    /*


Note below, in the case of no errors we provided the user a completion message, which should be brought back. We were also showing a failure message in the case of error, so perhaps this needs to be setup in a try/catch around ExecutePSCommandAsync since it now throws errors.

Just realised we can't both WriteOutputToHost and see if the command errored here. This seems to be the only place where we want to do that... Need to think on this a bit

I've had an idea but want to separate out that work -- I'll open an issue

andyleejordan · 2021-09-30T18:01:08Z

src/PowerShellEditorServices/Services/PowerShell/Handlers/PSHostProcessAndRunspaceHandlers.cs

@@ -11,17 +11,19 @@

 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
+    using Microsoft.PowerShell.EditorServices.Services.PowerShell;
+    using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
    using System.Management.Automation;


Story for later is massive usings cleanup.

andyleejordan · 2021-09-30T18:11:50Z

src/PowerShellEditorServices/Services/PowerShell/Host/HostStartOptions.cs

+
+namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Host
+{
+    internal struct HostStartOptions


Is this still a thing?

andyleejordan · 2021-09-30T18:13:00Z

src/PowerShellEditorServices/Services/PowerShell/Host/PowerShellFactory.cs

+    {
+        private static readonly string s_commandsModulePath = Path.GetFullPath(
+            Path.Combine(
+                Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),


Oof we've really got to make this a util.

andyleejordan · 2021-09-30T18:44:22Z

src/PowerShellEditorServices/Services/PowerShell/Runspace/SessionDetails.cs

+            return new SessionDetails(
+                (int)detailsObject[Property_ProcessId],
+                (string)detailsObject[Property_ComputerName],
+                (Guid?)detailsObject[Property_InstanceId]);


Something to look at and potentially cleanup later (but was existing code).

andyleejordan · 2021-09-30T18:51:49Z

src/PowerShellEditorServices/Services/PowerShell/Utility/CancellationContext.cs

+
+namespace Microsoft.PowerShell.EditorServices.Services.PowerShell.Utility
+{
+    internal class CancellationContext


This class seems pretty core, it could use explanation and why it exists and how it works.

andyleejordan · 2021-09-30T18:53:45Z

src/PowerShellEditorServices/Services/PowerShell/Utility/CommandHelpers.cs

+            // This mechanism only works in-process
+            if (currentRunspace.RunspaceOrigin != RunspaceOrigin.Local)
+            {
+                return null;


Should we return null or should we be throwing an error or what?

andyleejordan · 2021-09-30T18:56:53Z

src/PowerShellEditorServices/Services/PowerShell/Utility/CommandHelpers.cs

+            PSCommand command = new PSCommand()
+                .AddCommand(@"Microsoft.PowerShell.Core\Get-Command")
+                .AddArgument(commandName)
+                .AddParameter("ErrorAction", "Ignore");


We potentially want Stop so we actually get these errors and don't just place them in $error, but that's a change to contemplate later.

I should mention (from #1575) that the current ErrorAction value is called SilentlyContinue, not Ignore, so if any of these are kept they should at least be changed to the right value.

We potentially want Stop so we actually get these errors and don't just place them in $error, but that's a change to contemplate later.

Ignore is the option that actually hides it from $error. The reason we get some leaky errors is due to parameter binding errors which completely ignore action preference set via common parameters.

@alexbuzzbee Ignore was added back in PSv3, see ActionPreference

@alexbuzzbee let's restrict that discussion to its own issue. This PR is already extremely large.

andyleejordan · 2021-09-30T18:58:48Z

src/PowerShellEditorServices/Services/PowerShell/Utility/CommandHelpers.cs

+            {
+                commandInfo = result;
+                break;
+            }


Looks like we should just use FirstOrDefault?

andyleejordan

Yay only console stuff left!

andyleejordan · 2021-09-30T21:05:58Z

src/PowerShellEditorServices/Services/PowerShell/Utility/ErrorRecordExtensions.cs

+        static ErrorRecordExtensions()
+        {
+            if (VersionUtils.IsPS7OrGreater)
+            {
+                // Used to write ErrorRecords to the Error stream. Using Public and NonPublic because the plan is to make this property
+                // public in 7.0.1
+                PropertyInfo writeStreamProperty = typeof(PSObject).GetProperty("WriteStream", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+                Type writeStreamType = typeof(PSObject).Assembly.GetType("System.Management.Automation.WriteStreamType");
+                object errorStreamType = Enum.Parse(writeStreamType, "Error");
+
+                var errorObjectParameter = Expression.Parameter(typeof(PSObject));
+
+                s_setWriteStreamProperty = Expression.Lambda<Action<PSObject>>(
+                    Expression.Call(
+                        errorObjectParameter,
+                        writeStreamProperty.GetSetMethod(),
+                        Expression.Constant(errorStreamType)), 
+                    errorObjectParameter)
+                    .Compile();


This is very dense, please explain it.

Very hacky PowerShell stuff.

andyleejordan · 2021-09-30T21:16:15Z

src/PowerShellEditorServices/Services/PowerShell/Utility/PSCommandExtensions.cs

+            return psCommand;
+        }
+
+        public static string GetInvocationText(this PSCommand command)


Might want to note this is explicitly for logging and not for passing to PowerShell to execute as a script.

andyleejordan · 2021-09-30T21:32:26Z

src/PowerShellEditorServices/Services/PowerShell/Utility/RunspaceExtensions.cs

+        static RunspaceExtensions()
+        {
+            // PowerShell ApartmentState APIs aren't available in PSStandard, so we need to use reflection.
+            if (!VersionUtils.IsNetCore || VersionUtils.IsPS7OrGreater)


We'll want to remove the whole if statement because we were attempting to run separate code for PowerShell 6 where a hole in the support existed, but that support has been discontinued.

andyleejordan · 2021-09-30T21:33:08Z

src/PowerShellEditorServices/Services/PowerShell/Utility/RunspaceExtensions.cs

+            return s_getRemotePromptFunc(runspace, basePrompt);
+        }
+
+        public static bool IsUsable(this RunspaceStateInfo runspaceStateInfo)


Double check if this is still in use.

andyleejordan · 2021-09-30T21:36:15Z

src/PowerShellEditorServices/Services/PowerShellContext/PowerShellContextService.cs

@@ -20,6 +20,7 @@
 using Microsoft.PowerShell.EditorServices.Logging;
 using Microsoft.PowerShell.EditorServices.Services.PowerShellContext;
 using Microsoft.PowerShell.EditorServices.Utility;
+using SMA = System.Management.Automation;


For the other places where we're using an internal using statement to fix this namespace type collision, let's change them to this form of SMA.PowerShell to be consistent about the clear typing.

andyleejordan · 2021-09-30T21:54:29Z