Bring code up to compilation

Author: rjmholt

src/PowerShellEditorServices/Server/PsesServiceCollectionExtensions.cs

@@ -12,6 +12,9 @@
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.Extension;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
 using Microsoft.PowerShell.EditorServices.Services.Template;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 
@@ -25,12 +28,18 @@ public static IServiceCollection AddPsesLanguageServices(
         {
             return collection.AddSingleton<WorkspaceService>()
                 .AddSingleton<SymbolsService>()
-                .AddSingleton<ConfigurationService>()
-                .AddSingleton<PowerShellExecutionService>(
-                    (provider) => PowerShellExecutionService.CreateAndStart(
+                .AddSingleton<EditorServicesConsolePSHost>(
+                    (provider) => EditorServicesConsolePSHost.Create(
                         provider.GetService<ILoggerFactory>(),
                         provider.GetService<ILanguageServer>(),
                         hostStartupInfo))
+                .AddSingleton<IRunspaceContext>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>())
+                .AddSingleton<PowerShellExecutionService>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>().ExecutionService)
+                .AddSingleton<ConfigurationService>()
+                .AddSingleton<IPowerShellDebugContext>(
+                    (provider) => provider.GetService<EditorServicesConsolePSHost>().DebugContext)
                 .AddSingleton<TemplateService>()
                 .AddSingleton<EditorOperationsService>()
                 .AddSingleton<RemoteFileManagerService>()

src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs

@@ -43,6 +43,8 @@ internal class DebugService
 
         private readonly EditorServicesConsolePSHost _psesHost;
 
+        private readonly IPowerShellDebugContext _debugContext;
+
         private int nextVariableId;
         private string temporaryScriptListingPath;
         private List<VariableDetailsBase> variables;
@@ -68,7 +70,7 @@ internal class DebugService
         /// Gets a boolean that indicates whether the debugger is currently
         /// stopped at a breakpoint.
         /// </summary>
-        public bool IsDebuggerStopped => _executionService.DebugContext.IsStopped;
+        public bool IsDebuggerStopped => _debugContext.IsStopped;
 
         /// <summary>
         /// Gets the current DebuggerStoppedEventArgs when the debugger
@@ -106,6 +108,7 @@ internal class DebugService
         /// <param name="logger">An ILogger implementation used for writing log messages.</param>
         public DebugService(
             PowerShellExecutionService executionService,
+            IPowerShellDebugContext debugContext,
             RemoteFileManagerService remoteFileManager,
             BreakpointService breakpointService,
             EditorServicesConsolePSHost psesHost,
@@ -117,9 +120,10 @@ public DebugService(
             _executionService = executionService;
             _breakpointService = breakpointService;
             _psesHost = psesHost;
-            _executionService.DebugContext.DebuggerStopped += this.OnDebuggerStopAsync;
-            _executionService.DebugContext.DebuggerResuming += this.OnDebuggerResuming;
-            _executionService.DebugContext.BreakpointUpdated += this.OnBreakpointUpdated;
+            _debugContext = debugContext;
+            _debugContext.DebuggerStopped += OnDebuggerStopAsync;
+            _debugContext.DebuggerResuming += OnDebuggerResuming;
+            _debugContext.BreakpointUpdated += OnBreakpointUpdated;
 
             this.remoteFileManager = remoteFileManager;
 
@@ -146,11 +150,11 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
             BreakpointDetails[] breakpoints,
             bool clearExisting = true)
         {
-            DscBreakpointCapability dscBreakpoints = _executionService.CurrentRunspace.DscBreakpointCapability;
+            DscBreakpointCapability dscBreakpoints = await _debugContext.GetDscBreakpointCapabilityAsync(CancellationToken.None);
 
             string scriptPath = scriptFile.FilePath;
             // Make sure we're using the remote script path
-            if (_psesHost.Runspace.RunspaceIsRemote
+            if (_psesHost.CurrentRunspace.IsOnRemoteMachine
                 && this.remoteFileManager != null)
             {
                 if (!this.remoteFileManager.IsUnderRemoteTempPath(scriptPath))
@@ -164,7 +168,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
                 string mappedPath =
                     this.remoteFileManager.GetMappedPath(
                         scriptPath,
-                        _executionService.CurrentRunspace);
+                        _psesHost.CurrentRunspace);
 
                 scriptPath = mappedPath;
             }
@@ -229,31 +233,31 @@ public async Task<CommandBreakpointDetails[]> SetCommandBreakpointsAsync(
         /// </summary>
         public void Continue()
         {
-            _executionService.DebugContext.Continue();
+            _debugContext.Continue();
         }
 
         /// <summary>
         /// Sends a "step over" action to the debugger when stopped.
         /// </summary>
         public void StepOver()
         {
-            _executionService.DebugContext.StepOver();
+            _debugContext.StepOver();
         }
 
         /// <summary>
         /// Sends a "step in" action to the debugger when stopped.
         /// </summary>
         public void StepIn()
         {
-            _executionService.DebugContext.StepInto();
+            _debugContext.StepInto();
         }
 
         /// <summary>
         /// Sends a "step out" action to the debugger when stopped.
         /// </summary>
         public void StepOut()
         {
-            _executionService.DebugContext.StepOut();
+            _debugContext.StepOut();
         }
 
         /// <summary>
@@ -263,7 +267,7 @@ public void StepOut()
         /// </summary>
         public void Break()
         {
-            _executionService.DebugContext.BreakExecution();
+            _debugContext.BreakExecution();
         }
 
         /// <summary>
@@ -272,7 +276,7 @@ public void Break()
         /// </summary>
         public void Abort()
         {
-            _executionService.DebugContext.Abort();
+            _debugContext.Abort();
         }
 
         /// <summary>
@@ -809,7 +813,7 @@ private async Task FetchStackFramesAsync(string scriptNameOverride)
 
                 // When debugging, this is the best way I can find to get what is likely the workspace root.
                 // This is controlled by the "cwd:" setting in the launch config.
-                string workspaceRootPath = _executionService.PowerShellContext.InitialWorkingDirectory;
+                string workspaceRootPath = _psesHost.InitialWorkingDirectory;
 
                 this.stackFrameDetails[i] =
                     StackFrameDetails.Create(callStackFrames[i], autoVariables, localVariables, workspaceRootPath);
@@ -820,14 +824,14 @@ private async Task FetchStackFramesAsync(string scriptNameOverride)
                 {
                     this.stackFrameDetails[i].ScriptPath = scriptNameOverride;
                 }
-                else if (_executionService.CurrentRunspace.IsRemote()
+                else if (_psesHost.CurrentRunspace.IsOnRemoteMachine
                     && this.remoteFileManager != null
                     && !string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
                 {
                     this.stackFrameDetails[i].ScriptPath =
                         this.remoteFileManager.GetMappedPath(
                             stackFrameScriptPath,
-                            _executionService.CurrentRunspace);
+                            _psesHost.CurrentRunspace);
                 }
             }
         }
@@ -889,9 +893,9 @@ await _executionService.ExecutePSCommandAsync<PSObject>(
 
                     this.temporaryScriptListingPath =
                         this.remoteFileManager.CreateTemporaryFile(
-                            $"[{_executionService.CurrentRunspace.SessionDetails.ComputerName}] {TemporaryScriptFileName}",
+                            $"[{_psesHost.CurrentRunspace.SessionDetails.ComputerName}] {TemporaryScriptFileName}",
                             scriptListing,
-                            _executionService.CurrentRunspace);
+                            _psesHost.CurrentRunspace);
 
                     localScriptPath =
                         this.temporaryScriptListingPath
@@ -911,14 +915,14 @@ await this.FetchStackFramesAndVariablesAsync(
 
             // If this is a remote connection and the debugger stopped at a line
             // in a script file, get the file contents
-            if (_executionService.CurrentRunspace.IsRemote()
+            if (_psesHost.CurrentRunspace.IsOnRemoteMachine
                 && this.remoteFileManager != null
                 && !noScriptName)
             {
                 localScriptPath =
                     await this.remoteFileManager.FetchRemoteFileAsync(
                         e.InvocationInfo.ScriptName,
-                        _executionService.CurrentRunspace).ConfigureAwait(false);
+                        _psesHost.CurrentRunspace).ConfigureAwait(false);
             }
 
             if (this.stackFrameDetails.Length > 0)
@@ -938,7 +942,7 @@ await this.remoteFileManager.FetchRemoteFileAsync(
             this.CurrentDebuggerStoppedEventArgs =
                 new DebuggerStoppedEventArgs(
                     e,
-                    _executionService.CurrentRunspace,
+                    _psesHost.CurrentRunspace,
                     localScriptPath);
 
             // Notify the host that the debugger is stopped
@@ -967,13 +971,13 @@ private void OnBreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
             if (e.Breakpoint is LineBreakpoint lineBreakpoint)
             {
                 string scriptPath = lineBreakpoint.Script;
-                if (_executionService.CurrentRunspace.IsRemote()
+                if (_psesHost.CurrentRunspace.IsOnRemoteMachine
                     && this.remoteFileManager != null)
                 {
                     string mappedPath =
                         this.remoteFileManager.GetMappedPath(
                             scriptPath,
-                            _executionService.CurrentRunspace);
+                            _psesHost.CurrentRunspace);
 
                     if (mappedPath == null)
                     {

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

@@ -29,7 +29,7 @@ internal class DebuggerStoppedEventArgs
         /// </summary>
         public bool IsRemoteSession
         {
-            get => RunspaceInfo.IsRemote();
+            get => RunspaceInfo.RunspaceOrigin != RunspaceOrigin.Local;
         }
 
         /// <summary>

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

@@ -11,22 +11,26 @@
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.DebugAdapter;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
     internal class DebugEvaluateHandler : IEvaluateHandler
     {
         private readonly ILogger _logger;
+        private readonly IPowerShellDebugContext _debugContext;
         private readonly PowerShellExecutionService _executionService;
         private readonly DebugService _debugService;
 
         public DebugEvaluateHandler(
             ILoggerFactory factory,
+            IPowerShellDebugContext debugContext,
             PowerShellExecutionService executionService,
             DebugService debugService)
         {
             _logger = factory.CreateLogger<DebugEvaluateHandler>();
+            _debugContext = debugContext;
             _executionService = executionService;
             _debugService = debugService;
         }
@@ -56,7 +60,7 @@ public async Task<EvaluateResponseBody> Handle(EvaluateRequestArguments request,
 
                 // VS Code might send this request after the debugger
                 // has been resumed, return an empty result in this case.
-                if (_executionService.DebugContext.IsStopped)
+                if (_debugContext.IsStopped)
                 {
                     // First check to see if the watch expression refers to a naked variable reference.
                     result =

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

@@ -8,10 +8,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Logging;
 using Microsoft.PowerShell.EditorServices.Server;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Host;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
 
@@ -25,17 +27,20 @@ internal class DisconnectHandler : IDisconnectHandler
         private readonly DebugStateService _debugStateService;
         private readonly DebugEventHandlerService _debugEventHandlerService;
         private readonly PsesDebugServer _psesDebugServer;
+        private readonly IRunspaceContext _runspaceContext;
 
         public DisconnectHandler(
             ILoggerFactory factory,
             PsesDebugServer psesDebugServer,
+            IRunspaceContext runspaceContext,
             PowerShellExecutionService executionService,
             DebugService debugService,
             DebugStateService debugStateService,
             DebugEventHandlerService debugEventHandlerService)
         {
             _logger = factory.CreateLogger<DisconnectHandler>();
             _psesDebugServer = psesDebugServer;
+            _runspaceContext = runspaceContext;
             _executionService = executionService;
             _debugService = debugService;
             _debugStateService = debugStateService;
@@ -53,7 +58,7 @@ public async Task<DisconnectResponse> Handle(DisconnectArguments request, Cancel
                 if (_debugStateService.IsInteractiveDebugSession && _debugStateService.IsAttachSession)
                 {
                     // Pop the sessions
-                    if (_executionService.CurrentRunspace.RunspaceOrigin == RunspaceOrigin.EnteredProcess)
+                    if (_runspaceContext.CurrentRunspace.RunspaceOrigin == RunspaceOrigin.EnteredProcess)
                     {
                         try
                         {
@@ -63,7 +68,7 @@ await _executionService.ExecutePSCommandAsync(
                                 CancellationToken.None).ConfigureAwait(false);
 
                             if (_debugStateService.IsRemoteAttach &&
-                                _executionService.CurrentRunspace.IsRemote())
+                                _runspaceContext.CurrentRunspace.RunspaceOrigin == RunspaceOrigin.EnteredProcess)
                             {
                                 await _executionService.ExecutePSCommandAsync(
                                     new PSCommand().AddCommand("Exit-PSSession"),