Remove useless ToArray of BreakpointDetails

This can just be an `IEnumerable` throughout instead.

Author: andyleejordan

src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs

@@ -130,9 +130,9 @@ public DebugService(
         /// <param name="breakpoints">BreakpointDetails for each breakpoint that will be set.</param>
         /// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
         /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
-        public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
+        public async Task<IEnumerable<BreakpointDetails>> SetLineBreakpointsAsync(
             ScriptFile scriptFile,
-            BreakpointDetails[] breakpoints,
+            IEnumerable<BreakpointDetails> breakpoints,
             bool clearExisting = true)
         {
             DscBreakpointCapability dscBreakpoints = await _debugContext.GetDscBreakpointCapabilityAsync(CancellationToken.None).ConfigureAwait(false);
@@ -146,15 +146,15 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
                 if (!_remoteFileManager.IsUnderRemoteTempPath(scriptPath))
                 {
                     _logger.LogTrace($"Could not set breakpoints for local path '{scriptPath}' in a remote session.");
-                    return Array.Empty<BreakpointDetails>();
+                    return Enumerable.Empty<BreakpointDetails>();
                 }
 
                 scriptPath = _remoteFileManager.GetMappedPath(scriptPath, _psesHost.CurrentRunspace);
             }
             else if (temporaryScriptListingPath?.Equals(scriptPath, StringComparison.CurrentCultureIgnoreCase) == true)
             {
                 _logger.LogTrace($"Could not set breakpoint on temporary script listing path '{scriptPath}'.");
-                return Array.Empty<BreakpointDetails>();
+                return Enumerable.Empty<BreakpointDetails>();
             }
 
             // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
@@ -168,7 +168,7 @@ public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
                     await _breakpointService.RemoveAllBreakpointsAsync(scriptFile.FilePath).ConfigureAwait(false);
                 }
 
-                return (await _breakpointService.SetBreakpointsAsync(escapedScriptPath, breakpoints).ConfigureAwait(false)).ToArray();
+                return await _breakpointService.SetBreakpointsAsync(escapedScriptPath, breakpoints).ConfigureAwait(false);
             }
 
             return await dscBreakpoints

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

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -82,18 +83,17 @@ public async Task<SetBreakpointsResponse> Handle(SetBreakpointsArguments request
             }
 
             // At this point, the source file has been verified as a PowerShell script.
-            BreakpointDetails[] breakpointDetails = request.Breakpoints
+            IEnumerable<BreakpointDetails> breakpointDetails = request.Breakpoints
                 .Select((srcBreakpoint) => BreakpointDetails.Create(
                     scriptFile.FilePath,
                     srcBreakpoint.Line,
                     srcBreakpoint.Column,
                     srcBreakpoint.Condition,
                     srcBreakpoint.HitCondition,
-                    srcBreakpoint.LogMessage))
-                .ToArray();
+                    srcBreakpoint.LogMessage));
 
             // If this is a "run without debugging (Ctrl+F5)" session ignore requests to set breakpoints.
-            BreakpointDetails[] updatedBreakpointDetails = breakpointDetails;
+            IEnumerable<BreakpointDetails> updatedBreakpointDetails = breakpointDetails;
             if (!_debugStateService.NoDebug)
             {
                 await _debugStateService.WaitForSetBreakpointHandleAsync().ConfigureAwait(false);

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

@@ -22,24 +22,19 @@ internal class DscBreakpointCapability
     {
         private string[] dscResourceRootPaths = Array.Empty<string>();
 
-        private readonly Dictionary<string, int[]> breakpointsPerFile =
-            new();
+        private readonly Dictionary<string, int[]> breakpointsPerFile = new();
 
-        public async Task<BreakpointDetails[]> SetLineBreakpointsAsync(
+        public async Task<IEnumerable<BreakpointDetails>> SetLineBreakpointsAsync(
             IInternalPowerShellExecutionService executionService,
             string scriptPath,
-            BreakpointDetails[] breakpoints)
+            IEnumerable<BreakpointDetails> breakpoints)
         {
-            List<BreakpointDetails> resultBreakpointDetails =
-                new();
-
             // We always get the latest array of breakpoint line numbers
             // so store that for future use
-            if (breakpoints.Length > 0)
+            if (breakpoints.Any())
             {
                 // Set the breakpoints for this scriptPath
-                breakpointsPerFile[scriptPath] =
-                    breakpoints.Select(b => b.LineNumber).ToArray();
+                breakpointsPerFile[scriptPath] = breakpoints.Select(b => b.LineNumber).ToArray();
             }
             else
             {
@@ -72,7 +67,7 @@ await executionService.ExecutePSCommandAsync(
                 breakpoint.Verified = true;
             }
 
-            return breakpoints.ToArray();
+            return breakpoints;
         }
 
         public bool IsDscResourcePath(string scriptPath)

test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs

@@ -203,7 +203,7 @@ await debugService.SetCommandBreakpointsAsync(
         [MemberData(nameof(DebuggerAcceptsScriptArgsTestData))]
         public async Task DebuggerAcceptsScriptArgs(string[] args)
         {
-            BreakpointDetails[] breakpoints = await debugService.SetLineBreakpointsAsync(
+            IEnumerable<BreakpointDetails> breakpoints = await debugService.SetLineBreakpointsAsync(
                 oddPathScriptFile,
                 new[] { BreakpointDetails.Create(oddPathScriptFile.FilePath, 3) }).ConfigureAwait(true);
 
@@ -264,8 +264,8 @@ public async Task DebuggerSetsAndClearsFunctionBreakpoints()
                 }).ConfigureAwait(true);
 
             Assert.Equal(2, breakpoints.Length);
-            Assert.Equal("Write-Host", breakpoints[0].Name);
-            Assert.Equal("Get-Date", breakpoints[1].Name);
+            Assert.Equal("Write-Host", breakpoints.ElementAt(0).Name);
+            Assert.Equal("Get-Date", breakpoints.ElementAt(1).Name);
 
             breakpoints = await debugService.SetCommandBreakpointsAsync(
                 new[] { CommandBreakpointDetails.Create("Get-Host") }).ConfigureAwait(true);
@@ -311,7 +311,7 @@ public async Task DebuggerStopsOnFunctionBreakpoints()
         [Fact]
         public async Task DebuggerSetsAndClearsLineBreakpoints()
         {
-            BreakpointDetails[] breakpoints =
+            IEnumerable<BreakpointDetails> breakpoints =
                 await debugService.SetLineBreakpointsAsync(
                     debugScriptFile,
                     new[] {
@@ -322,16 +322,16 @@ await debugService.SetLineBreakpointsAsync(
             IReadOnlyList<LineBreakpoint> confirmedBreakpoints = await GetConfirmedBreakpoints(debugScriptFile).ConfigureAwait(true);
 
             Assert.Equal(2, confirmedBreakpoints.Count);
-            Assert.Equal(5, breakpoints[0].LineNumber);
-            Assert.Equal(10, breakpoints[1].LineNumber);
+            Assert.Equal(5, breakpoints.ElementAt(0).LineNumber);
+            Assert.Equal(10, breakpoints.ElementAt(1).LineNumber);
 
             breakpoints = await debugService.SetLineBreakpointsAsync(
                 debugScriptFile,
                 new[] { BreakpointDetails.Create(debugScriptFile.FilePath, 2) }).ConfigureAwait(true);
             confirmedBreakpoints = await GetConfirmedBreakpoints(debugScriptFile).ConfigureAwait(true);
 
             Assert.Single(confirmedBreakpoints);
-            Assert.Equal(2, breakpoints[0].LineNumber);
+            Assert.Equal(2, breakpoints.ElementAt(0).LineNumber);
 
             await debugService.SetLineBreakpointsAsync(
                 debugScriptFile,
@@ -442,7 +442,7 @@ await debugService.SetLineBreakpointsAsync(
         [Fact]
         public async Task DebuggerProvidesMessageForInvalidConditionalBreakpoint()
         {
-            BreakpointDetails[] breakpoints =
+            IEnumerable<BreakpointDetails> breakpoints =
                 await debugService.SetLineBreakpointsAsync(
                     debugScriptFile,
                     new[] {
@@ -457,36 +457,36 @@ await debugService.SetLineBreakpointsAsync(
                     }).ConfigureAwait(true);
 
             Assert.Single(breakpoints);
-            // Assert.Equal(5, breakpoints[0].LineNumber);
-            // Assert.True(breakpoints[0].Verified);
-            // Assert.Null(breakpoints[0].Message);
-
-            Assert.Equal(10, breakpoints[0].LineNumber);
-            Assert.False(breakpoints[0].Verified);
-            Assert.NotNull(breakpoints[0].Message);
-            Assert.Contains("Unexpected token '-ez'", breakpoints[0].Message);
+            // Assert.Equal(5, breakpoints.ElementAt(0).LineNumber);
+            // Assert.True(breakpoints.ElementAt(0).Verified);
+            // Assert.Null(breakpoints.ElementAt(0).Message);
+
+            Assert.Equal(10, breakpoints.ElementAt(0).LineNumber);
+            Assert.False(breakpoints.ElementAt(0).Verified);
+            Assert.NotNull(breakpoints.ElementAt(0).Message);
+            Assert.Contains("Unexpected token '-ez'", breakpoints.ElementAt(0).Message);
         }
 
         [Fact]
         public async Task DebuggerFindsParsableButInvalidSimpleBreakpointConditions()
         {
-            BreakpointDetails[] breakpoints =
+            IEnumerable<BreakpointDetails> breakpoints =
                 await debugService.SetLineBreakpointsAsync(
                     debugScriptFile,
                     new[] {
                         BreakpointDetails.Create(debugScriptFile.FilePath, 5, column: null, condition: "$i == 100"),
                         BreakpointDetails.Create(debugScriptFile.FilePath, 7, column: null, condition: "$i > 100")
                     }).ConfigureAwait(true);
 
-            Assert.Equal(2, breakpoints.Length);
-            Assert.Equal(5, breakpoints[0].LineNumber);
-            Assert.False(breakpoints[0].Verified);
-            Assert.Contains("Use '-eq' instead of '=='", breakpoints[0].Message);
-
-            Assert.Equal(7, breakpoints[1].LineNumber);
-            Assert.False(breakpoints[1].Verified);
-            Assert.NotNull(breakpoints[1].Message);
-            Assert.Contains("Use '-gt' instead of '>'", breakpoints[1].Message);
+            Assert.Equal(2, breakpoints.Count());
+            Assert.Equal(5, breakpoints.ElementAt(0).LineNumber);
+            Assert.False(breakpoints.ElementAt(0).Verified);
+            Assert.Contains("Use '-eq' instead of '=='", breakpoints.ElementAt(0).Message);
+
+            Assert.Equal(7, breakpoints.ElementAt(1).LineNumber);
+            Assert.False(breakpoints.ElementAt(1).Verified);
+            Assert.NotNull(breakpoints.ElementAt(1).Message);
+            Assert.Contains("Use '-gt' instead of '>'", breakpoints.ElementAt(1).Message);
         }
 
         [Fact]