Clean up breakpoint files (#1701)

andyleejordan · web-flow · commit d9e6fb5f1cce · 2022-02-10T09:50:29.000-08:00
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs b/src/PowerShellEditorServices/Services/DebugAdapter/BreakpointService.cs
@@ -23,11 +23,9 @@ internal class BreakpointService
         private readonly DebugStateService _debugStateService;
 
         // TODO: This needs to be managed per nested session
-        internal readonly Dictionary<string, HashSet<Breakpoint>> BreakpointsPerFile =
-            new Dictionary<string, HashSet<Breakpoint>>();
+        internal readonly Dictionary<string, HashSet<Breakpoint>> BreakpointsPerFile = new();
 
-        internal readonly HashSet<Breakpoint> CommandBreakpoints =
-            new HashSet<Breakpoint>();
+        internal readonly HashSet<Breakpoint> CommandBreakpoints = new();
 
         public BreakpointService(
             ILoggerFactory factory,
@@ -51,9 +49,11 @@ public async Task<List<Breakpoint>> GetBreakpointsAsync()
             }
 
             // Legacy behavior
-            PSCommand psCommand = new PSCommand()
-                .AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
-            IEnumerable<Breakpoint> breakpoints = await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
+            PSCommand psCommand = new PSCommand().AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
+            IEnumerable<Breakpoint> breakpoints = await _executionService
+                .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)
+                .ConfigureAwait(false);
+
             return breakpoints.ToList();
         }
 
@@ -73,13 +73,12 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
                         breakpointDetails.Verified = false;
                     }
                 }
-
                 return breakpoints;
             }
 
             // Legacy behavior
             PSCommand psCommand = null;
-            List<BreakpointDetails> configuredBreakpoints = new List<BreakpointDetails>();
+            List<BreakpointDetails> configuredBreakpoints = new();
             foreach (BreakpointDetails breakpoint in breakpoints)
             {
                 ScriptBlock actionScriptBlock = null;
@@ -106,7 +105,7 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
 
                 // On first iteration psCommand will be null, every subsequent
                 // iteration will need to start a new statement.
-                if (psCommand == null)
+                if (psCommand is null)
                 {
                     psCommand = new PSCommand();
                 }
@@ -121,61 +120,61 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc
                     .AddParameter("Line", breakpoint.LineNumber);
 
                 // Check if the user has specified the column number for the breakpoint.
-                if (breakpoint.ColumnNumber.HasValue && breakpoint.ColumnNumber.Value > 0)
+                if (breakpoint.ColumnNumber > 0)
                 {
                     // It bums me out that PowerShell will silently ignore a breakpoint
                     // where either the line or the column is invalid.  I'd rather have an
                     // error or warning message I could relay back to the client.
                     psCommand.AddParameter("Column", breakpoint.ColumnNumber.Value);
                 }
 
-                if (actionScriptBlock != null)
+                if (actionScriptBlock is not null)
                 {
                     psCommand.AddParameter("Action", actionScriptBlock);
                 }
             }
 
             // If no PSCommand was created then there are no breakpoints to set.
-            if (psCommand != null)
+            if (psCommand is not null)
             {
-                IEnumerable<Breakpoint> setBreakpoints =
-                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
-                configuredBreakpoints.AddRange(
-                    setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint))
-                );
+                IEnumerable<Breakpoint> setBreakpoints = await _executionService
+                    .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)
+                    .ConfigureAwait(false);
+                configuredBreakpoints.AddRange(setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint)));
             }
-
             return configuredBreakpoints;
         }
 
-        public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(IEnumerable<CommandBreakpointDetails> breakpoints)
+        public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpointsAsync(IEnumerable<CommandBreakpointDetails> breakpoints)
         {
             if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))
             {
                 foreach (CommandBreakpointDetails commandBreakpointDetails in breakpoints)
                 {
                     try
                     {
-                        BreakpointApiUtils.SetBreakpoint(_editorServicesHost.Runspace.Debugger, commandBreakpointDetails, _debugStateService.RunspaceId);
+                        BreakpointApiUtils.SetBreakpoint(
+                            _editorServicesHost.Runspace.Debugger,
+                            commandBreakpointDetails,
+                            _debugStateService.RunspaceId);
                     }
-                    catch(InvalidOperationException e)
+                    catch (InvalidOperationException e)
                     {
                         commandBreakpointDetails.Message = e.Message;
                         commandBreakpointDetails.Verified = false;
                     }
                 }
-
                 return breakpoints;
             }
 
             // Legacy behavior
             PSCommand psCommand = null;
-            List<CommandBreakpointDetails> configuredBreakpoints = new List<CommandBreakpointDetails>();
+            List<CommandBreakpointDetails> configuredBreakpoints = new();
             foreach (CommandBreakpointDetails breakpoint in breakpoints)
             {
                 // On first iteration psCommand will be null, every subsequent
                 // iteration will need to start a new statement.
-                if (psCommand == null)
+                if (psCommand is null)
                 {
                     psCommand = new PSCommand();
                 }
@@ -208,20 +207,18 @@ public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(I
                         configuredBreakpoints.Add(breakpoint);
                         continue;
                     }
-
                     psCommand.AddParameter("Action", actionScriptBlock);
                 }
             }
 
             // If no PSCommand was created then there are no breakpoints to set.
-            if (psCommand != null)
+            if (psCommand is not null)
             {
-                IEnumerable<Breakpoint> setBreakpoints =
-                    await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);
-                configuredBreakpoints.AddRange(
-                    setBreakpoints.Select(CommandBreakpointDetails.Create));
+                IEnumerable<Breakpoint> setBreakpoints = await _executionService
+                    .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)
+                    .ConfigureAwait(false);
+                configuredBreakpoints.AddRange(setBreakpoints.Select(CommandBreakpointDetails.Create));
             }
-
             return configuredBreakpoints;
         }
 
@@ -238,30 +235,26 @@ public async Task RemoveAllBreakpointsAsync(string scriptPath = null)
                             _editorServicesHost.Runspace.Debugger,
                             _debugStateService.RunspaceId))
                     {
-                        if (scriptPath == null || scriptPath == breakpoint.Script)
+                        if (scriptPath is null || scriptPath == breakpoint.Script)
                         {
                             BreakpointApiUtils.RemoveBreakpoint(
                                 _editorServicesHost.Runspace.Debugger,
                                 breakpoint,
                                 _debugStateService.RunspaceId);
                         }
                     }
-
                     return;
                 }
 
                 // Legacy behavior
-
-                PSCommand psCommand = new PSCommand();
-                psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
+                var psCommand = new PSCommand().AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");
 
                 if (!string.IsNullOrEmpty(scriptPath))
                 {
                     psCommand.AddParameter("Script", scriptPath);
                 }
 
                 psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");
-
                 await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);
             }
             catch (Exception e)
@@ -281,37 +274,26 @@ public async Task RemoveBreakpointsAsync(IEnumerable<Breakpoint> breakpoints)
                         breakpoint,
                         _debugStateService.RunspaceId);
 
-                    switch (breakpoint)
+                    _ = breakpoint switch
                     {
-                        case CommandBreakpoint commandBreakpoint:
-                            CommandBreakpoints.Remove(commandBreakpoint);
-                            break;
-                        case LineBreakpoint lineBreakpoint:
-                            if (BreakpointsPerFile.TryGetValue(lineBreakpoint.Script, out HashSet<Breakpoint> bps))
-                            {
-                                bps.Remove(lineBreakpoint);
-                            }
-                            break;
-                        default:
-                            throw new ArgumentException("Unsupported breakpoint type.");
-                    }
+                        CommandBreakpoint commandBreakpoint => CommandBreakpoints.Remove(commandBreakpoint),
+                        LineBreakpoint lineBreakpoint =>
+                            BreakpointsPerFile.TryGetValue(lineBreakpoint.Script, out HashSet<Breakpoint> bps) && bps.Remove(lineBreakpoint),
+                        _ => throw new NotImplementedException("Other breakpoints not supported yet"),
+                    };
                 }
-
                 return;
             }
 
             // Legacy behavior
-            var breakpointIds = breakpoints.Select(b => b.Id).ToArray();
-            if(breakpointIds.Length > 0)
+            var breakpointIds = breakpoints.Select(b => b.Id);
+            if (breakpointIds.Any())
             {
-                PSCommand psCommand = new PSCommand();
-                psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");
-                psCommand.AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());
-
+                PSCommand psCommand = new PSCommand()
+                    .AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint")
+                    .AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());
                 await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);
             }
         }
-
-
     }
 }
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs b/src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs
@@ -185,7 +185,7 @@ public async Task<CommandBreakpointDetails[]> SetCommandBreakpointsAsync(
 
             if (breakpoints.Length > 0)
             {
-                resultBreakpointDetails = (await _breakpointService.SetCommandBreakpoints(breakpoints).ConfigureAwait(false)).ToArray();
+                resultBreakpointDetails = (await _breakpointService.SetCommandBreakpointsAsync(breakpoints).ConfigureAwait(false)).ToArray();
             }
 
             return resultBreakpointDetails ?? Array.Empty<CommandBreakpointDetails>();
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointApiUtils.cs b/src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointApiUtils.cs
@@ -134,17 +134,24 @@ public static Breakpoint SetBreakpoint(Debugger debugger, BreakpointDetailsBase
                 }
             }
 
-            switch (breakpoint)
+            return breakpoint switch
             {
-                case BreakpointDetails lineBreakpoint:
-                    return SetLineBreakpointDelegate(debugger, lineBreakpoint.Source, lineBreakpoint.LineNumber, lineBreakpoint.ColumnNumber ?? 0, actionScriptBlock, runspaceId);
-
-                case CommandBreakpointDetails commandBreakpoint:
-                    return SetCommandBreakpointDelegate(debugger, commandBreakpoint.Name, null, null, runspaceId);
-
-                default:
-                    throw new NotImplementedException("Other breakpoints not supported yet");
-            }
+                BreakpointDetails lineBreakpoint => SetLineBreakpointDelegate(
+                    debugger,
+                    lineBreakpoint.Source,
+                    lineBreakpoint.LineNumber,
+                    lineBreakpoint.ColumnNumber ?? 0,
+                    actionScriptBlock,
+                    runspaceId),
+
+                CommandBreakpointDetails commandBreakpoint => SetCommandBreakpointDelegate(debugger,
+                    commandBreakpoint.Name,
+                    null,
+                    null,
+                    runspaceId),
+
+                _ => throw new NotImplementedException("Other breakpoints not supported yet"),
+            };
         }
 
         public static List<Breakpoint> GetBreakpoints(Debugger debugger, int? runspaceId = null)
@@ -173,20 +180,20 @@ public static ScriptBlock GetBreakpointActionScriptBlock(string condition, strin
 
             try
             {
-                StringBuilder builder = new StringBuilder(
+                StringBuilder builder = new(
                     string.IsNullOrEmpty(logMessage)
                         ? "break"
                         : $"Microsoft.PowerShell.Utility\\Write-Host \"{logMessage.Replace("\"","`\"")}\"");
 
                 // If HitCondition specified, parse and verify it.
-                if (!(string.IsNullOrWhiteSpace(hitCondition)))
+                if (!string.IsNullOrWhiteSpace(hitCondition))
                 {
                     if (!int.TryParse(hitCondition, out int parsedHitCount))
                     {
                         throw new InvalidOperationException("Hit Count was not a valid integer.");
                     }
 
-                    if(string.IsNullOrWhiteSpace(condition))
+                    if (string.IsNullOrWhiteSpace(condition))
                     {
                         // In the HitCount only case, this is simple as we can just use the HitCount
                         // property on the breakpoint object which is represented by $_.
@@ -217,8 +224,7 @@ public static ScriptBlock GetBreakpointActionScriptBlock(string condition, strin
                     // Check for "advanced" condition syntax i.e. if the user has specified
                     // a "break" or  "continue" statement anywhere in their scriptblock,
                     // pass their scriptblock through to the Action parameter as-is.
-                    if (parsed.Ast.Find(ast =>
-                        (ast is BreakStatementAst || ast is ContinueStatementAst), true) != null)
+                    if (parsed.Ast.Find(ast => ast is BreakStatementAst || ast is ContinueStatementAst, true) is not null)
                     {
                         return parsed;
                     }
@@ -247,10 +253,9 @@ private static bool ValidateBreakpointConditionAst(Ast conditionAst, out string
 
             // We are only inspecting a few simple scenarios in the EndBlock only.
             if (conditionAst is ScriptBlockAst scriptBlockAst &&
-                scriptBlockAst.BeginBlock == null &&
-                scriptBlockAst.ProcessBlock == null &&
-                scriptBlockAst.EndBlock != null &&
-                scriptBlockAst.EndBlock.Statements.Count == 1)
+                scriptBlockAst.BeginBlock is null &&
+                scriptBlockAst.ProcessBlock is null &&
+                scriptBlockAst.EndBlock?.Statements.Count == 1)
             {
                 StatementAst statementAst = scriptBlockAst.EndBlock.Statements[0];
                 string condition = statementAst.Extent.Text;
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointDetails.cs b/src/PowerShellEditorServices/Services/DebugAdapter/Debugging/BreakpointDetails.cs
@@ -30,7 +30,7 @@ internal class BreakpointDetails : BreakpointDetailsBase
         public int LineNumber { get; private set; }
 
         /// <summary>
-        /// Gets the column number at which the breakpoint is set. If null, the default of 1 is used.
+        /// Gets the column number at which the breakpoint is set.
         /// </summary>
         public int? ColumnNumber { get; private set; }
 
@@ -83,9 +83,9 @@ internal static BreakpointDetails Create(
             Breakpoint breakpoint,
             BreakpointUpdateType updateType = BreakpointUpdateType.Set)
         {
-            Validate.IsNotNull("breakpoint", breakpoint);
+            Validate.IsNotNull(nameof(breakpoint), breakpoint);
 
-            if (!(breakpoint is LineBreakpoint lineBreakpoint))
+            if (breakpoint is not LineBreakpoint lineBreakpoint)
             {
                 throw new ArgumentException(
                     "Unexpected breakpoint type: " + breakpoint.GetType().Name);

Original file line number	Diff line number	Diff line change
`@@ -23,11 +23,9 @@ internal class BreakpointService`
`23`	`23`	`private readonly DebugStateService _debugStateService;`
`24`	`24`
`25`	`25`	`// TODO: This needs to be managed per nested session`
`26`		`- internal readonly Dictionary<string, HashSet<Breakpoint>> BreakpointsPerFile =`
`27`		`- new Dictionary<string, HashSet<Breakpoint>>();`
	`26`	`+ internal readonly Dictionary<string, HashSet<Breakpoint>> BreakpointsPerFile = new();`
`28`	`27`
`29`		`- internal readonly HashSet<Breakpoint> CommandBreakpoints =`
`30`		`- new HashSet<Breakpoint>();`
	`28`	`+ internal readonly HashSet<Breakpoint> CommandBreakpoints = new();`
`31`	`29`
`32`	`30`	`public BreakpointService(`
`33`	`31`	`ILoggerFactory factory,`
`@@ -51,9 +49,11 @@ public async Task<List<Breakpoint>> GetBreakpointsAsync()`
`51`	`49`	`}`
`52`	`50`
`53`	`51`	`// Legacy behavior`
`54`		`- PSCommand psCommand = new PSCommand()`
`55`		`- .AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");`
`56`		`- IEnumerable<Breakpoint> breakpoints = await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);`
	`52`	`+ PSCommand psCommand = new PSCommand().AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");`
	`53`	`+ IEnumerable<Breakpoint> breakpoints = await _executionService`
	`54`	`+ .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)`
	`55`	`+ .ConfigureAwait(false);`
	`56`	`+`
`57`	`57`	`return breakpoints.ToList();`
`58`	`58`	`}`
`59`	`59`
`@@ -73,13 +73,12 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc`
`73`	`73`	`breakpointDetails.Verified = false;`
`74`	`74`	`}`
`75`	`75`	`}`
`76`		`-`
`77`	`76`	`return breakpoints;`
`78`	`77`	`}`
`79`	`78`
`80`	`79`	`// Legacy behavior`
`81`	`80`	`PSCommand psCommand = null;`
`82`		`- List<BreakpointDetails> configuredBreakpoints = new List<BreakpointDetails>();`
	`81`	`+ List<BreakpointDetails> configuredBreakpoints = new();`
`83`	`82`	`foreach (BreakpointDetails breakpoint in breakpoints)`
`84`	`83`	`{`
`85`	`84`	`ScriptBlock actionScriptBlock = null;`
`@@ -106,7 +105,7 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc`
`106`	`105`
`107`	`106`	`// On first iteration psCommand will be null, every subsequent`
`108`	`107`	`// iteration will need to start a new statement.`
`109`		`- if (psCommand == null)`
	`108`	`+ if (psCommand is null)`
`110`	`109`	`{`
`111`	`110`	`psCommand = new PSCommand();`
`112`	`111`	`}`
`@@ -121,61 +120,61 @@ public async Task<IEnumerable<BreakpointDetails>> SetBreakpointsAsync(string esc`
`121`	`120`	`.AddParameter("Line", breakpoint.LineNumber);`
`122`	`121`
`123`	`122`	`// Check if the user has specified the column number for the breakpoint.`
`124`		`- if (breakpoint.ColumnNumber.HasValue && breakpoint.ColumnNumber.Value > 0)`
	`123`	`+ if (breakpoint.ColumnNumber > 0)`
`125`	`124`	`{`
`126`	`125`	`// It bums me out that PowerShell will silently ignore a breakpoint`
`127`	`126`	`// where either the line or the column is invalid. I'd rather have an`
`128`	`127`	`// error or warning message I could relay back to the client.`
`129`	`128`	`psCommand.AddParameter("Column", breakpoint.ColumnNumber.Value);`
`130`	`129`	`}`
`131`	`130`
`132`		`- if (actionScriptBlock != null)`
	`131`	`+ if (actionScriptBlock is not null)`
`133`	`132`	`{`
`134`	`133`	`psCommand.AddParameter("Action", actionScriptBlock);`
`135`	`134`	`}`
`136`	`135`	`}`
`137`	`136`
`138`	`137`	`// If no PSCommand was created then there are no breakpoints to set.`
`139`		`- if (psCommand != null)`
	`138`	`+ if (psCommand is not null)`
`140`	`139`	`{`
`141`		`- IEnumerable<Breakpoint> setBreakpoints =`
`142`		`- await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);`
`143`		`- configuredBreakpoints.AddRange(`
`144`		`- setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint))`
`145`		`- );`
	`140`	`+ IEnumerable<Breakpoint> setBreakpoints = await _executionService`
	`141`	`+ .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)`
	`142`	`+ .ConfigureAwait(false);`
	`143`	`+ configuredBreakpoints.AddRange(setBreakpoints.Select((breakpoint) => BreakpointDetails.Create(breakpoint)));`
`146`	`144`	`}`
`147`		`-`
`148`	`145`	`return configuredBreakpoints;`
`149`	`146`	`}`
`150`	`147`
`151`		`- public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(IEnumerable<CommandBreakpointDetails> breakpoints)`
	`148`	`+ public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpointsAsync(IEnumerable<CommandBreakpointDetails> breakpoints)`
`152`	`149`	`{`
`153`	`150`	`if (BreakpointApiUtils.SupportsBreakpointApis(_editorServicesHost.CurrentRunspace))`
`154`	`151`	`{`
`155`	`152`	`foreach (CommandBreakpointDetails commandBreakpointDetails in breakpoints)`
`156`	`153`	`{`
`157`	`154`	`try`
`158`	`155`	`{`
`159`		`- BreakpointApiUtils.SetBreakpoint(_editorServicesHost.Runspace.Debugger, commandBreakpointDetails, _debugStateService.RunspaceId);`
	`156`	`+ BreakpointApiUtils.SetBreakpoint(`
	`157`	`+ _editorServicesHost.Runspace.Debugger,`
	`158`	`+ commandBreakpointDetails,`
	`159`	`+ _debugStateService.RunspaceId);`
`160`	`160`	`}`
`161`		`- catch(InvalidOperationException e)`
	`161`	`+ catch (InvalidOperationException e)`
`162`	`162`	`{`
`163`	`163`	`commandBreakpointDetails.Message = e.Message;`
`164`	`164`	`commandBreakpointDetails.Verified = false;`
`165`	`165`	`}`
`166`	`166`	`}`
`167`		`-`
`168`	`167`	`return breakpoints;`
`169`	`168`	`}`
`170`	`169`
`171`	`170`	`// Legacy behavior`
`172`	`171`	`PSCommand psCommand = null;`
`173`		`- List<CommandBreakpointDetails> configuredBreakpoints = new List<CommandBreakpointDetails>();`
	`172`	`+ List<CommandBreakpointDetails> configuredBreakpoints = new();`
`174`	`173`	`foreach (CommandBreakpointDetails breakpoint in breakpoints)`
`175`	`174`	`{`
`176`	`175`	`// On first iteration psCommand will be null, every subsequent`
`177`	`176`	`// iteration will need to start a new statement.`
`178`		`- if (psCommand == null)`
	`177`	`+ if (psCommand is null)`
`179`	`178`	`{`
`180`	`179`	`psCommand = new PSCommand();`
`181`	`180`	`}`
`@@ -208,20 +207,18 @@ public async Task<IEnumerable<CommandBreakpointDetails>> SetCommandBreakpoints(I`
`208`	`207`	`configuredBreakpoints.Add(breakpoint);`
`209`	`208`	`continue;`
`210`	`209`	`}`
`211`		`-`
`212`	`210`	`psCommand.AddParameter("Action", actionScriptBlock);`
`213`	`211`	`}`
`214`	`212`	`}`
`215`	`213`
`216`	`214`	`// If no PSCommand was created then there are no breakpoints to set.`
`217`		`- if (psCommand != null)`
	`215`	`+ if (psCommand is not null)`
`218`	`216`	`{`
`219`		`- IEnumerable<Breakpoint> setBreakpoints =`
`220`		`- await _executionService.ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None).ConfigureAwait(false);`
`221`		`- configuredBreakpoints.AddRange(`
`222`		`- setBreakpoints.Select(CommandBreakpointDetails.Create));`
	`217`	`+ IEnumerable<Breakpoint> setBreakpoints = await _executionService`
	`218`	`+ .ExecutePSCommandAsync<Breakpoint>(psCommand, CancellationToken.None)`
	`219`	`+ .ConfigureAwait(false);`
	`220`	`+ configuredBreakpoints.AddRange(setBreakpoints.Select(CommandBreakpointDetails.Create));`
`223`	`221`	`}`
`224`		`-`
`225`	`222`	`return configuredBreakpoints;`
`226`	`223`	`}`
`227`	`224`
`@@ -238,30 +235,26 @@ public async Task RemoveAllBreakpointsAsync(string scriptPath = null)`
`238`	`235`	`_editorServicesHost.Runspace.Debugger,`
`239`	`236`	`_debugStateService.RunspaceId))`
`240`	`237`	`{`
`241`		`- if (scriptPath == null \|\| scriptPath == breakpoint.Script)`
	`238`	`+ if (scriptPath is null \|\| scriptPath == breakpoint.Script)`
`242`	`239`	`{`
`243`	`240`	`BreakpointApiUtils.RemoveBreakpoint(`
`244`	`241`	`_editorServicesHost.Runspace.Debugger,`
`245`	`242`	`breakpoint,`
`246`	`243`	`_debugStateService.RunspaceId);`
`247`	`244`	`}`
`248`	`245`	`}`
`249`		`-`
`250`	`246`	`return;`
`251`	`247`	`}`
`252`	`248`
`253`	`249`	`// Legacy behavior`
`254`		`-`
`255`		`- PSCommand psCommand = new PSCommand();`
`256`		`- psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");`
	`250`	`+ var psCommand = new PSCommand().AddCommand(@"Microsoft.PowerShell.Utility\Get-PSBreakpoint");`
`257`	`251`
`258`	`252`	`if (!string.IsNullOrEmpty(scriptPath))`
`259`	`253`	`{`
`260`	`254`	`psCommand.AddParameter("Script", scriptPath);`
`261`	`255`	`}`
`262`	`256`
`263`	`257`	`psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");`
`264`		`-`
`265`	`258`	`await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);`
`266`	`259`	`}`
`267`	`260`	`catch (Exception e)`
`@@ -281,37 +274,26 @@ public async Task RemoveBreakpointsAsync(IEnumerable<Breakpoint> breakpoints)`
`281`	`274`	`breakpoint,`
`282`	`275`	`_debugStateService.RunspaceId);`
`283`	`276`
`284`		`- switch (breakpoint)`
	`277`	`+ _ = breakpoint switch`
`285`	`278`	`{`
`286`		`- case CommandBreakpoint commandBreakpoint:`
`287`		`- CommandBreakpoints.Remove(commandBreakpoint);`
`288`		`- break;`
`289`		`- case LineBreakpoint lineBreakpoint:`
`290`		`- if (BreakpointsPerFile.TryGetValue(lineBreakpoint.Script, out HashSet<Breakpoint> bps))`
`291`		`- {`
`292`		`- bps.Remove(lineBreakpoint);`
`293`		`- }`
`294`		`- break;`
`295`		`- default:`
`296`		`- throw new ArgumentException("Unsupported breakpoint type.");`
`297`		`- }`
	`279`	`+ CommandBreakpoint commandBreakpoint => CommandBreakpoints.Remove(commandBreakpoint),`
	`280`	`+ LineBreakpoint lineBreakpoint =>`
	`281`	`+ BreakpointsPerFile.TryGetValue(lineBreakpoint.Script, out HashSet<Breakpoint> bps) && bps.Remove(lineBreakpoint),`
	`282`	`+ _ => throw new NotImplementedException("Other breakpoints not supported yet"),`
	`283`	`+ };`
`298`	`284`	`}`
`299`		`-`
`300`	`285`	`return;`
`301`	`286`	`}`
`302`	`287`
`303`	`288`	`// Legacy behavior`
`304`		`- var breakpointIds = breakpoints.Select(b => b.Id).ToArray();`
`305`		`- if(breakpointIds.Length > 0)`
	`289`	`+ var breakpointIds = breakpoints.Select(b => b.Id);`
	`290`	`+ if (breakpointIds.Any())`
`306`	`291`	`{`
`307`		`- PSCommand psCommand = new PSCommand();`
`308`		`- psCommand.AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint");`
`309`		`- psCommand.AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());`
`310`		`-`
	`292`	`+ PSCommand psCommand = new PSCommand()`
	`293`	`+ .AddCommand(@"Microsoft.PowerShell.Utility\Remove-PSBreakpoint")`
	`294`	`+ .AddParameter("Id", breakpoints.Select(b => b.Id).ToArray());`
`311`	`295`	`await _executionService.ExecutePSCommandAsync<object>(psCommand, CancellationToken.None).ConfigureAwait(false);`
`312`	`296`	`}`
`313`	`297`	`}`
`314`		`-`
`315`		`-`
`316`	`298`	`}`
`317`	`299`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ public async Task<CommandBreakpointDetails[]> SetCommandBreakpointsAsync(`
`185`	`185`
`186`	`186`	`if (breakpoints.Length > 0)`
`187`	`187`	`{`
`188`		`- resultBreakpointDetails = (await _breakpointService.SetCommandBreakpoints(breakpoints).ConfigureAwait(false)).ToArray();`
	`188`	`+ resultBreakpointDetails = (await _breakpointService.SetCommandBreakpointsAsync(breakpoints).ConfigureAwait(false)).ToArray();`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`return resultBreakpointDetails ?? Array.Empty<CommandBreakpointDetails>();`