use more collection expressions and mark as error for Rider and R# in editorconfig (#5377)

Author: SimonCropp

.editorconfig

@@ -689,8 +689,8 @@ resharper_empty_constructor_highlighting = warning
 # Redundant empty argument list on object creation expression
 resharper_redundant_empty_object_creation_argument_list_highlighting = warning
 
-# IDE0300: Simplify collection initialization
-dotnet_style_prefer_collection_expression = false
+# IDE0300-IDE0306: Simplify collection initialization
+dotnet_style_prefer_collection_expression = true
 
 # IDE0065: using directive placement
 csharp_using_directive_placement = outside_namespace:warning

samples/Playground/Program.cs

@@ -57,15 +57,15 @@ public static async Task<int> Main(string[] args)
             using TestingPlatformClient client = await TestingPlatformClientFactory.StartAsServerAndConnectToTheClientAsync(Environment.ProcessPath!);
 
             await client.InitializeAsync();
-            List<TestNodeUpdate> testNodeUpdates = new();
+            List<TestNodeUpdate> testNodeUpdates = [];
             ResponseListener discoveryResponse = await client.DiscoverTestsAsync(Guid.NewGuid(), node =>
             {
                 testNodeUpdates.AddRange(node);
                 return Task.CompletedTask;
             });
             await discoveryResponse.WaitCompletionAsync();
 
-            ResponseListener runRequest = await client.RunTestsAsync(Guid.NewGuid(), testNodeUpdates.Select(x => x.Node).ToArray(), _ => Task.CompletedTask);
+            ResponseListener runRequest = await client.RunTestsAsync(Guid.NewGuid(), [.. testNodeUpdates.Select(x => x.Node)], _ => Task.CompletedTask);
             await runRequest.WaitCompletionAsync();
 
             await client.ExitAsync();
@@ -86,7 +86,7 @@ internal sealed class DummyAdapter : ITestFramework, IDataProducer
 
     public string Description => string.Empty;
 
-    public Type[] DataTypesProduced => new[] { typeof(TestNodeUpdateMessage) };
+    public Type[] DataTypesProduced => [typeof(TestNodeUpdateMessage)];
 
     public Task<CloseTestSessionResult> CloseTestSessionAsync(CloseTestSessionContext context) => Task.FromResult(new CloseTestSessionResult { IsSuccess = true });
 

samples/Playground/ServerMode/TestNodeUpdateCollector.cs

@@ -10,7 +10,7 @@ public class TestNodeUpdateCollector
     private readonly TaskCompletionSource _taskCompletionSource = new();
     private readonly Func<TestNodeUpdate, bool>? _completeCollector;
 
-    public ConcurrentBag<TestNodeUpdate> TestNodeUpdates { get; } = new();
+    public ConcurrentBag<TestNodeUpdate> TestNodeUpdates { get; } = [];
 
     public TestNodeUpdateCollector(Func<TestNodeUpdate, bool>? completeCollectorWhen = null) => _completeCollector = completeCollectorWhen;
 

samples/Playground/ServerMode/v1.0.0/TestingPlatformClient.cs

@@ -171,11 +171,9 @@ private sealed class TargetHandler
         private readonly ConcurrentDictionary<Guid, ResponseListener> _listeners
             = new();
 
-        private readonly ConcurrentBag<LogsCollector> _logListeners
-            = new();
+        private readonly ConcurrentBag<LogsCollector> _logListeners = [];
 
-        private readonly ConcurrentBag<TelemetryCollector> _telemetryPayloads
-            = new();
+        private readonly ConcurrentBag<TelemetryCollector> _telemetryPayloads = [];
 
         public void RegisterTelemetryListener(TelemetryCollector listener)
             => _telemetryPayloads.Add(listener);

src/Adapter/MSTest.Engine/Engine/BFSTestNodeVisitor.cs

@@ -29,12 +29,12 @@ public BFSTestNodeVisitor(IEnumerable<TestNode> rootTestNodes, ITestExecutionFil
         _testArgumentsManager = testArgumentsManager;
     }
 
-    internal KeyValuePair<TestNodeUid, List<TestNode>>[] DuplicatedNodes { get; private set; } = Array.Empty<KeyValuePair<TestNodeUid, List<TestNode>>>();
+    internal KeyValuePair<TestNodeUid, List<TestNode>>[] DuplicatedNodes { get; private set; } = [];
 
     public async Task VisitAsync(Func<TestNode, TestNodeUid?, Task> onIncludedTestNodeAsync)
     {
         // This is case sensitive, and culture insensitive, to keep UIDs unique, and comparable between different system.
-        Dictionary<TestNodeUid, List<TestNode>> testNodesByUid = new();
+        Dictionary<TestNodeUid, List<TestNode>> testNodesByUid = [];
         Queue<(TestNode CurrentNode, TestNodeUid? ParentNodeUid, StringBuilder NodeFullPath)> queue = new();
         foreach (TestNode node in _rootTestNodes)
         {
@@ -47,7 +47,7 @@ public async Task VisitAsync(Func<TestNode, TestNodeUid?, Task> onIncludedTestNo
 
             if (!testNodesByUid.TryGetValue(currentNode.StableUid, out List<TestNode>? testNodes))
             {
-                testNodes = new();
+                testNodes = [];
                 testNodesByUid.Add(currentNode.StableUid, testNodes);
             }
 
@@ -94,7 +94,7 @@ public async Task VisitAsync(Func<TestNode, TestNodeUid?, Task> onIncludedTestNo
             }
         }
 
-        DuplicatedNodes = testNodesByUid.Where(x => x.Value.Count > 1).ToArray();
+        DuplicatedNodes = [.. testNodesByUid.Where(x => x.Value.Count > 1)];
     }
 
     private static PropertyBag CreatePropertyBagForFilter(IProperty[] properties)

src/Adapter/MSTest.Engine/Engine/TestArgumentsManager.cs

@@ -7,7 +7,7 @@ namespace Microsoft.Testing.Framework;
 
 internal sealed class TestArgumentsManager : ITestArgumentsManager
 {
-    private readonly Dictionary<TestNodeUid, Func<TestArgumentsContext, ITestArgumentsEntry>> _testArgumentsEntryProviders = new();
+    private readonly Dictionary<TestNodeUid, Func<TestArgumentsContext, ITestArgumentsEntry>> _testArgumentsEntryProviders = [];
     private bool _isRegistrationFrozen;
 
     public void RegisterTestArgumentsEntryProvider<TArguments>(
@@ -53,8 +53,8 @@ internal async Task<TestNode> ExpandTestNodeAsync(TestNode currentNode)
             };
         }
 
-        HashSet<TestNodeUid> expandedTestNodeUids = new();
-        List<TestNode> expandedTestNodes = new(currentNode.Tests);
+        HashSet<TestNodeUid> expandedTestNodeUids = [];
+        List<TestNode> expandedTestNodes = [.. currentNode.Tests];
         switch (currentNode)
         {
             case IParameterizedTestNode parameterizedTestNode:
@@ -98,7 +98,7 @@ internal async Task<TestNode> ExpandTestNodeAsync(TestNode currentNode)
             DisplayName = currentNode.DisplayName,
             OverriddenEdgeName = currentNode.OverriddenEdgeName,
             Properties = currentNode.Properties,
-            Tests = expandedTestNodes.ToArray(),
+            Tests = [.. expandedTestNodes],
         };
 
         return expandedNode;

src/Adapter/MSTest.Engine/Engine/TestFixtureManager.cs

@@ -10,13 +10,13 @@ namespace Microsoft.Testing.Framework;
 
 internal sealed class TestFixtureManager : ITestFixtureManager
 {
-    private readonly Dictionary<FixtureId, Dictionary<Type, AsyncLazy<object>>> _fixtureInstancesByFixtureId = new();
-    private readonly Dictionary<TestNode, FixtureId[]> _fixtureIdsUsedByTestNode = new();
+    private readonly Dictionary<FixtureId, Dictionary<Type, AsyncLazy<object>>> _fixtureInstancesByFixtureId = [];
+    private readonly Dictionary<TestNode, FixtureId[]> _fixtureIdsUsedByTestNode = [];
 
     // We could improve this by doing some optimistic lock but we expect a rather low contention on this.
     // We use a dictionary as performance improvement because we know that when the registration is complete
     // we will only read the collection (so no need for concurrency handling).
-    private readonly Dictionary<FixtureId, CountHolder> _fixtureUses = new();
+    private readonly Dictionary<FixtureId, CountHolder> _fixtureUses = [];
     private readonly CancellationToken _cancellationToken;
     private bool _isRegistrationFrozen;
     private bool _isUsageRegistrationFrozen;
@@ -79,7 +79,7 @@ internal void RegisterFixtureUsage(TestNode testNode, string[] fixtureIds)
             return;
         }
 
-        _fixtureIdsUsedByTestNode.Add(testNode, fixtureIds.Select(x => new FixtureId(x)).ToArray());
+        _fixtureIdsUsedByTestNode.Add(testNode, [.. fixtureIds.Select(x => new FixtureId(x))]);
         foreach (string fixtureId in fixtureIds)
         {
             if (!_fixtureUses.TryGetValue(fixtureId, out CountHolder? uses))

src/Adapter/MSTest.Engine/Engine/TestFrameworkEngine.cs

@@ -38,8 +38,7 @@ public TestFrameworkEngine(TestFrameworkConfiguration testFrameworkConfiguration
         _configuration = new(configuration);
     }
 
-    public Type[] DataTypesProduced { get; }
-        = new Type[1] { typeof(TestNodeUpdateMessage) };
+    public Type[] DataTypesProduced { get; } = [typeof(TestNodeUpdateMessage)];
 
     public string Uid => _extension.Uid;
 
@@ -62,7 +61,7 @@ public async Task<Result> ExecuteRequestAsync(TestExecutionRequest testExecution
     private async Task<Result> ExecuteTestNodeRunAsync(RunTestExecutionRequest request, IMessageBus messageBus,
         CancellationToken cancellationToken)
     {
-        List<TestNode> allRootTestNodes = new();
+        List<TestNode> allRootTestNodes = [];
         TestFixtureManager fixtureManager = new(cancellationToken);
         TestArgumentsManager argumentsManager = new();
         TestSessionContext testSessionContext = new(_configuration, fixtureManager, argumentsManager, request.Session.SessionUid,
@@ -96,7 +95,7 @@ await testNodesVisitor.VisitAsync((testNode, parentTestNodeUid) =>
                     .OfType<FrameworkEngineMetadataProperty>()
                     .SingleOrDefault()
                     .UsedFixtureIds
-                    ?? Array.Empty<string>();
+                    ?? [];
                 fixtureManager.RegisterFixtureUsage(testNode, fixtureIds);
 
                 return Task.CompletedTask;
@@ -142,7 +141,7 @@ Task PublishDataAsync(IData data)
     private async Task<Result> ExecuteTestNodeDiscoveryAsync(DiscoverTestExecutionRequest request, IMessageBus messageBus,
         CancellationToken cancellationToken)
     {
-        List<TestNode> allRootTestNodes = new();
+        List<TestNode> allRootTestNodes = [];
         TestFixtureManager fixtureManager = new(cancellationToken);
         TestArgumentsManager argumentsManager = new();
         TestSessionContext testSessionContext = new(_configuration, fixtureManager, argumentsManager, request.Session.SessionUid,

src/Adapter/MSTest.Engine/Engine/ThreadPoolTestNodeRunner.cs

@@ -16,7 +16,7 @@ namespace Microsoft.Testing.Framework;
 internal sealed class ThreadPoolTestNodeRunner : IDisposable
 {
     private readonly SemaphoreSlim? _maxParallelTests;
-    private readonly ConcurrentBag<Task<Result>> _runningTests = new();
+    private readonly ConcurrentBag<Task<Result>> _runningTests = [];
     private readonly ConcurrentDictionary<TestNodeUid, int> _runningTestNodeUids = new();
     private readonly CountdownEvent _ensureTaskQueuedCountdownEvent = new(1);
     private readonly Func<IData, Task> _publishDataAsync;

src/Adapter/MSTest.Engine/Helpers/Result.cs

@@ -5,7 +5,7 @@ namespace Microsoft.Testing.Framework;
 
 internal sealed class Result
 {
-    private readonly List<IReason> _reasons = new();
+    private readonly List<IReason> _reasons = [];
 
     private Result()
     {