WIP: FOUR tests passing! With less hacks.

Author: andyleejordan

src/PowerShellEditorServices/Services/DebugAdapter/DebugEventHandlerService.cs

@@ -131,8 +131,8 @@ private void OnDebuggerResuming(object sender, DebuggerResumingEventArgs e)
             _debugAdapterServer.SendNotification(EventNames.Continued,
                 new ContinuedEvent
                 {
-                    AllThreadsContinued = true,
                     ThreadId = ThreadsHandler.PipelineThread.Id,
+                    AllThreadsContinued = true,
                 });
         }
 
@@ -151,7 +151,7 @@ private void OnBreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
                     BreakpointDetails.Create(e.Breakpoint, e.UpdateType)
                 );
 
-                string reason = (e.UpdateType) switch {
+                string reason = e.UpdateType switch {
                     BreakpointUpdateType.Set => BreakpointEventReason.New,
                     BreakpointUpdateType.Removed => BreakpointEventReason.Removed,
                     BreakpointUpdateType.Enabled => BreakpointEventReason.Changed,

src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs

@@ -35,7 +35,7 @@ internal class DebugService
         private readonly ILogger _logger;
         private readonly IInternalPowerShellExecutionService _executionService;
         private readonly BreakpointService _breakpointService;
-        private readonly RemoteFileManagerService remoteFileManager;
+        private readonly RemoteFileManagerService _remoteFileManager;
 
         private readonly PsesInternalHost _psesHost;
 
@@ -82,26 +82,6 @@ internal class DebugService
         /// Initializes a new instance of the DebugService class and uses
         /// the given PowerShellContext for all future operations.
         /// </summary>
-        /// <param name="powerShellContext">
-        /// The PowerShellContext to use for all debugging operations.
-        /// </param>
-        /// <param name="logger">An ILogger implementation used for writing log messages.</param>
-        //public DebugService(PowerShellContextService powerShellContext, ILogger logger)
-        //    : this(powerShellContext, null, logger)
-        //{
-        //}
-
-        /// <summary>
-        /// Initializes a new instance of the DebugService class and uses
-        /// the given PowerShellContext for all future operations.
-        /// </summary>
-        /// <param name="powerShellContext">
-        /// The PowerShellContext to use for all debugging operations.
-        /// </param>
-        //// <param name = "remoteFileManager" >
-        //// A RemoteFileManagerService instance to use for accessing files in remote sessions.
-        //// </param>
-        /// <param name="logger">An ILogger implementation used for writing log messages.</param>
         public DebugService(
             IInternalPowerShellExecutionService executionService,
             IPowerShellDebugContext debugContext,
@@ -120,8 +100,7 @@ public DebugService(
             _debugContext.DebuggerStopped += OnDebuggerStopAsync;
             _debugContext.DebuggerResuming += OnDebuggerResuming;
             _debugContext.BreakpointUpdated += OnBreakpointUpdated;
-
-            this.remoteFileManager = remoteFileManager;
+            _remoteFileManager = remoteFileManager;
 
             invocationTypeScriptPositionProperty =
                 typeof(InvocationInfo)
@@ -150,32 +129,27 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
 
             string scriptPath = scriptFile.FilePath;
             // Make sure we're using the remote script path
-            if (_psesHost.CurrentRunspace.IsOnRemoteMachine && remoteFileManager is not null)
+            if (_psesHost.CurrentRunspace.IsOnRemoteMachine && _remoteFileManager is not null)
             {
-                if (!remoteFileManager.IsUnderRemoteTempPath(scriptPath))
+                if (!_remoteFileManager.IsUnderRemoteTempPath(scriptPath))
                 {
                     _logger.LogTrace($"Could not set breakpoints for local path '{scriptPath}' in a remote session.");
-
                     return Array.Empty<BreakpointDetails>();
                 }
 
-                string mappedPath = remoteFileManager.GetMappedPath(scriptPath, _psesHost.CurrentRunspace);
-
-                scriptPath = mappedPath;
+                scriptPath = _remoteFileManager.GetMappedPath(scriptPath, _psesHost.CurrentRunspace);
             }
-            else if (temporaryScriptListingPath is not null
-                && temporaryScriptListingPath.Equals(scriptPath, StringComparison.CurrentCultureIgnoreCase))
+            else if (temporaryScriptListingPath?.Equals(scriptPath, StringComparison.CurrentCultureIgnoreCase) == true)
             {
                 _logger.LogTrace($"Could not set breakpoint on temporary script listing path '{scriptPath}'.");
-
                 return Array.Empty<BreakpointDetails>();
             }
 
             // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
             // quoted and have those wildcard chars escaped.
             string escapedScriptPath = PathUtils.WildcardEscapePath(scriptPath);
 
-            if (dscBreakpoints is null || !dscBreakpoints.IsDscResourcePath(escapedScriptPath))
+            if (dscBreakpoints?.IsDscResourcePath(escapedScriptPath) != true)
             {
                 if (clearExisting)
                 {
@@ -185,11 +159,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
                 return (await _breakpointService.SetBreakpointsAsync(escapedScriptPath, breakpoints).ConfigureAwait(false)).ToArray();
             }
 
-            return await dscBreakpoints.SetLineBreakpointsAsync(
-                _executionService,
-                escapedScriptPath,
-                breakpoints)
-                .ConfigureAwait(false);
+            return await dscBreakpoints.SetLineBreakpointsAsync(_executionService, escapedScriptPath, breakpoints).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -362,7 +332,7 @@ public VariableDetailsBase GetVariableFromExpression(string variableExpression)
                                 variableName,
                                 StringComparison.CurrentCultureIgnoreCase));
 
-                if (resolvedVariable is not null && resolvedVariable.IsExpandable)
+                if (resolvedVariable?.IsExpandable == true)
                 {
                     // Continue by searching in this variable's children.
                     variableList = GetVariables(resolvedVariable.Id);
@@ -476,10 +446,10 @@ public async Task<string> SetVariableAsync(int variableContainerReferenceId, str
             {
                 _logger.LogTrace($"Setting variable '{name}' using conversion to value: {expressionResult ?? "<null>"}");
 
-                psVariable.Value = await _executionService.ExecuteDelegateAsync<object>(
+                psVariable.Value = await _executionService.ExecuteDelegateAsync(
                     "PS debugger argument converter",
                     ExecutionOptions.Default,
-                    (pwsh, cancellationToken) =>
+                    (pwsh, _) =>
                     {
                         var engineIntrinsics = (EngineIntrinsics)pwsh.Runspace.SessionStateProxy.GetVariable("ExecutionContext");
 
@@ -634,17 +604,14 @@ private async Task FetchStackFramesAndVariablesAsync(string scriptNameOverride)
                 nextVariableId = VariableDetailsBase.FirstVariableId;
                 variables = new List<VariableDetailsBase>
                 {
-
                     // Create a dummy variable for index 0, should never see this.
                     new VariableDetails("Dummy", null)
                 };
 
                 // Must retrieve in order of broadest to narrowest scope for efficient
                 // deduplication: global, script, local.
                 globalScopeVariables = await FetchVariableContainerAsync(VariableContainerDetails.GlobalScopeName).ConfigureAwait(false);
-
                 scriptScopeVariables = await FetchVariableContainerAsync(VariableContainerDetails.ScriptScopeName).ConfigureAwait(false);
-
                 localScopeVariables = await FetchVariableContainerAsync(VariableContainerDetails.LocalScopeName).ConfigureAwait(false);
 
                 await FetchStackFramesAsync(scriptNameOverride).ConfigureAwait(false);
@@ -662,9 +629,7 @@ private Task<VariableContainerDetails> FetchVariableContainerAsync(string scope)
 
         private async Task<VariableContainerDetails> FetchVariableContainerAsync(string scope, bool autoVarsOnly)
         {
-            PSCommand psCommand = new PSCommand()
-                .AddCommand("Get-Variable")
-                .AddParameter("Scope", scope);
+            PSCommand psCommand = new PSCommand().AddCommand("Get-Variable").AddParameter("Scope", scope);
 
             var scopeVariableContainer = new VariableContainerDetails(nextVariableId++, "Scope: " + scope);
             variables.Add(scopeVariableContainer);
@@ -674,17 +639,13 @@ private async Task<VariableContainerDetails> FetchVariableContainerAsync(string
             {
                 results = await _executionService.ExecutePSCommandAsync<PSObject>(psCommand, CancellationToken.None).ConfigureAwait(false);
             }
-            catch (CmdletInvocationException ex)
+            // It's possible to be asked to run `Get-Variable -Scope N` where N is a number that
+            // exceeds the available scopes. In this case, the command throws this exception, but
+            // there's nothing we can do about it, nor can we know the number of scopes that exist,
+            // and we shouldn't crash the debugger, so we just return no results instead. All other
+            // exceptions should be thrown again.
+            catch (CmdletInvocationException ex) when (ex.ErrorRecord.CategoryInfo.Reason.Equals("PSArgumentOutOfRangeException"))
             {
-                // It's possible to be asked to run `Get-Variable -Scope N` where N is a number that
-                // exceeds the available scopes. In this case, the command throws this exception,
-                // but there's nothing we can do about it, nor can we know the number of scopes that
-                // exist, and we shouldn't crash the debugger, so we just return no results instead.
-                // All other exceptions should be thrown again.
-                if (!ex.ErrorRecord.CategoryInfo.Reason.Equals("PSArgumentOutOfRangeException"))
-                {
-                    throw;
-                }
                 results = null;
             }
 
@@ -749,8 +710,8 @@ private static bool ShouldAddAsVariable(VariableInfo variableInfo)
         {
             // Filter built-in constant or readonly variables like $true, $false, $null, etc.
             ScopedItemOptions variableScope = variableInfo.Variable.Options;
-            var constantAllScope = ScopedItemOptions.AllScope | ScopedItemOptions.Constant;
-            var readonlyAllScope = ScopedItemOptions.AllScope | ScopedItemOptions.ReadOnly;
+            const ScopedItemOptions constantAllScope = ScopedItemOptions.AllScope | ScopedItemOptions.Constant;
+            const ScopedItemOptions readonlyAllScope = ScopedItemOptions.AllScope | ScopedItemOptions.ReadOnly;
             if (((variableScope & constantAllScope) == constantAllScope)
                 || ((variableScope & readonlyAllScope) == readonlyAllScope))
             {
@@ -909,11 +870,11 @@ private async Task FetchStackFramesAsync(string scriptNameOverride)
                     stackFrameDetailsEntry.ScriptPath = scriptNameOverride;
                 }
                 else if (isOnRemoteMachine
-                    && remoteFileManager is not null
+                    && _remoteFileManager is not null
                     && !string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
                 {
                     stackFrameDetailsEntry.ScriptPath =
-                        remoteFileManager.GetMappedPath(stackFrameScriptPath, _psesHost.CurrentRunspace);
+                        _remoteFileManager.GetMappedPath(stackFrameScriptPath, _psesHost.CurrentRunspace);
                 }
 
                 stackFrameDetailList.Add(stackFrameDetailsEntry);
@@ -957,7 +918,7 @@ internal async void OnDebuggerStopAsync(object sender, DebuggerStopEventArgs e)
             string localScriptPath = e.InvocationInfo?.ScriptName;
 
             // If there's no ScriptName, get the "list" of the current source
-            if (remoteFileManager is not null && string.IsNullOrEmpty(localScriptPath))
+            if (_remoteFileManager is not null && string.IsNullOrEmpty(localScriptPath))
             {
                 // Get the current script listing and create the buffer
                 PSCommand command = new PSCommand().AddScript($"list 1 {int.MaxValue}");
@@ -978,7 +939,7 @@ await _executionService.ExecutePSCommandAsync<PSObject>(
                                 .Where(s => s is not null));
 
                     temporaryScriptListingPath =
-                        remoteFileManager.CreateTemporaryFile(
+                        _remoteFileManager.CreateTemporaryFile(
                             $"[{_psesHost.CurrentRunspace.SessionDetails.ComputerName}] {TemporaryScriptFileName}",
                             scriptListing,
                             _psesHost.CurrentRunspace);
@@ -1001,19 +962,18 @@ await _executionService.ExecutePSCommandAsync<PSObject>(
             // If this is a remote connection and the debugger stopped at a line
             // in a script file, get the file contents
             if (_psesHost.CurrentRunspace.IsOnRemoteMachine
-                && remoteFileManager is not null
+                && _remoteFileManager is not null
                 && !noScriptName)
             {
                 localScriptPath =
-                    await remoteFileManager.FetchRemoteFileAsync(
+                    await _remoteFileManager.FetchRemoteFileAsync(
                         e.InvocationInfo.ScriptName,
                         _psesHost.CurrentRunspace).ConfigureAwait(false);
             }
 
             if (stackFrameDetails.Length > 0)
             {
                 // Augment the top stack frame with details from the stop event
-
                 if (e.InvocationInfo is not null
                     && invocationTypeScriptPositionProperty.GetValue(e.InvocationInfo) is IScriptExtent scriptExtent)
                 {
@@ -1056,9 +1016,9 @@ private void OnBreakpointUpdated(object sender, BreakpointUpdatedEventArgs e)
                 // TODO: This could be either a path or a script block!
                 string scriptPath = lineBreakpoint.Script;
                 if (_psesHost.CurrentRunspace.IsOnRemoteMachine
-                    && remoteFileManager is not null)
+                    && _remoteFileManager is not null)
                 {
-                    string mappedPath = remoteFileManager.GetMappedPath(scriptPath, _psesHost.CurrentRunspace);
+                    string mappedPath = _remoteFileManager.GetMappedPath(scriptPath, _psesHost.CurrentRunspace);
 
                     if (mappedPath is null)
                     {

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

@@ -70,7 +70,7 @@ public Task<ConfigurationDoneResponse> Handle(ConfigurationDoneArguments request
 
             if (_debugStateService.OwnsEditorSession)
             {
-                // If this is a debug-only session, we need to start
+                // TODO: If this is a debug-only session, we need to start
                 // the command loop manually
                 //_powerShellContextService.ConsoleReader.StartCommandLoop();
             }
@@ -81,22 +81,19 @@ public Task<ConfigurationDoneResponse> Handle(ConfigurationDoneArguments request
                     .HandleErrorsAsync(_logger);
             }
 
-            if (_debugStateService.IsInteractiveDebugSession)
+            if (_debugStateService.IsInteractiveDebugSession && _debugService.IsDebuggerStopped)
             {
-                if (_debugService.IsDebuggerStopped)
+                if (_debugService.CurrentDebuggerStoppedEventArgs is not null)
                 {
-                    if (_debugService.CurrentDebuggerStoppedEventArgs != null)
-                    {
-                        // If this is an interactive session and there's a pending breakpoint,
-                        // send that information along to the debugger client
-                        _debugEventHandlerService.TriggerDebuggerStopped(_debugService.CurrentDebuggerStoppedEventArgs);
-                    }
-                    else
-                    {
-                        // If this is an interactive session and there's a pending breakpoint that has not been propagated through
-                        // the debug service, fire the debug service's OnDebuggerStop event.
-                        _debugService.OnDebuggerStopAsync(null, _debugContext.LastStopEventArgs);
-                    }
+                    // If this is an interactive session and there's a pending breakpoint,
+                    // send that information along to the debugger client
+                    _debugEventHandlerService.TriggerDebuggerStopped(_debugService.CurrentDebuggerStoppedEventArgs);
+                }
+                else
+                {
+                    // If this is an interactive session and there's a pending breakpoint that has not been propagated through
+                    // the debug service, fire the debug service's OnDebuggerStop event.
+                    _debugService.OnDebuggerStopAsync(null, _debugContext.LastStopEventArgs);
                 }
             }
 
@@ -119,6 +116,8 @@ private async Task LaunchScriptAsync(string scriptToLaunch)
                     ScriptBlockAst ast = Parser.ParseInput(untitledScript.Contents, untitledScript.DocumentUri.ToString(), out Token[] tokens, out ParseError[] errors);
 
                     // This seems to be the simplest way to invoke a script block (which contains breakpoint information) via the PowerShell API.
+                    //
+                    // TODO: Fix this so the added script doesn't show up.
                     var cmd = new PSCommand().AddScript(". $args[0]").AddArgument(ast.GetScriptBlock());
                     await _executionService
                         .ExecutePSCommandAsync<object>(cmd, CancellationToken.None, s_debuggerExecutionOptions)

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

@@ -264,7 +264,7 @@ public void ClearTerminal()
             if (!TestHasLanguageServer(warnUser: false))
             {
                 return;
-            };
+            }
 
             _languageServer.SendNotification("editor/clearTerminal");
         }

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

@@ -106,6 +106,7 @@ public void StepOver()
 
         public void SetDebugResuming(DebuggerResumeAction debuggerResumeAction)
         {
+            // TODO: Why are we exiting?
             _psesHost.SetExit();
 
             if (LastStopEventArgs is not null)
@@ -115,7 +116,11 @@ public void SetDebugResuming(DebuggerResumeAction debuggerResumeAction)
 
             // We need to tell whatever is happening right now in the debug prompt to wrap up so we can continue
             // TODO: Except in the case of unit tests?
-            _psesHost.CancelCurrentTask();
+            if (_psesHost.UI is not NullPSHostUI)
+            // if (debuggerResumeAction is not DebuggerResumeAction.Continue)
+            {
+                _psesHost.CancelCurrentTask();
+            }
         }
 
         // This must be called AFTER the new PowerShell has been pushed
@@ -124,7 +129,6 @@ public void EnterDebugLoop(CancellationToken loopCancellationToken)
             RaiseDebuggerStoppedEvent();
         }
 
-
         // This must be called BEFORE the debug PowerShell has been popped
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "This method may acquire an implementation later, at which point it will need instance data")]
         public void ExitDebugLoop()
@@ -144,7 +148,7 @@ public void SetDebuggerResumed()
 
         public void ProcessDebuggerResult(DebuggerCommandResults debuggerResult)
         {
-            if (debuggerResult.ResumeAction != null)
+            if (debuggerResult.ResumeAction is not null)
             {
                 SetDebugResuming(debuggerResult.ResumeAction.Value);
                 RaiseDebuggerResumingEvent(new DebuggerResumingEventArgs(debuggerResult.ResumeAction.Value));