Code style: use c# 12 collection literals

Romfos · Romfos · commit cc9023e56c8e · 2024-05-10T12:48:19.000+02:00
diff --git a/.editorconfig b/.editorconfig
@@ -17,7 +17,9 @@ dotnet_style_qualification_for_field = false:suggestion
 dotnet_style_qualification_for_property = false:suggestion
 dotnet_style_qualification_for_method = false:suggestion
 dotnet_style_qualification_for_event = false:suggestion
-csharp_style_namespace_declarations=file_scoped:warning
+csharp_style_namespace_declarations = file_scoped:warning
+dotnet_style_prefer_collection_expression = true:warning
+dotnet_style_collection_initializer = true:warning
 
 # ReSharper properties
 resharper_int_align_switch_expressions = true
diff --git a/src/NSubstitute/Compatibility/DiagnosticsNullabilityAttributes.cs b/src/NSubstitute/Compatibility/DiagnosticsNullabilityAttributes.cs
@@ -90,7 +90,7 @@ internal sealed class MemberNotNullAttribute : Attribute
     /// <param name="member">
     /// The field or property member that is promised to be not-null.
     /// </param>
-    public MemberNotNullAttribute(string member) => Members = new[] { member };
+    public MemberNotNullAttribute(string member) => Members = [member];
 
     /// <summary>Initializes the attribute with the list of field and property members.</summary>
     /// <param name="members">
@@ -116,7 +116,7 @@ internal sealed class MemberNotNullWhenAttribute : Attribute
     public MemberNotNullWhenAttribute(bool returnValue, string member)
     {
         ReturnValue = returnValue;
-        Members = new[] { member };
+        Members = [member];
     }
 
     /// <summary>Initializes the attribute with the specified return value condition and list of field and property members.</summary>
diff --git a/src/NSubstitute/Core/ArgumentSpecificationDequeue.cs b/src/NSubstitute/Core/ArgumentSpecificationDequeue.cs
@@ -5,7 +5,7 @@ namespace NSubstitute.Core;
 
 public class ArgumentSpecificationDequeue : IArgumentSpecificationDequeue
 {
-    private static readonly IArgumentSpecification[] EmptySpecifications = new IArgumentSpecification[0];
+    private static readonly IArgumentSpecification[] EmptySpecifications = [];
 
     private readonly Func<IList<IArgumentSpecification>> _dequeueAllQueuedArgSpecs;
 
diff --git a/src/NSubstitute/Core/Arguments/ArrayContentsArgumentMatcher.cs b/src/NSubstitute/Core/Arguments/ArrayContentsArgumentMatcher.cs
@@ -31,7 +31,7 @@ public bool IsSatisfiedBy(object? argument)
 
     public string Format(object? argument, bool highlight)
     {
-        var argArray = argument is IEnumerable enumerableArgs ? enumerableArgs.Cast<object>().ToArray() : new object[0];
+        var argArray = argument is IEnumerable enumerableArgs ? enumerableArgs.Cast<object>().ToArray() : [];
         return Format(argArray, _argumentSpecifications).Join(", ");
     }
 
diff --git a/src/NSubstitute/Core/Call.cs b/src/NSubstitute/Core/Call.cs
@@ -81,7 +81,7 @@ public void AssignSequenceNumber(long number)
         object?[] originalArray = _originalArguments;
         if (originalArray == _arguments && originalArray.Length > 0)
         {
-            object?[] copy = originalArray.ToArray();
+            object?[] copy = [.. originalArray];
             // If it happens that _originalArguments doesn't point to the `_arguments` anymore -
             // it might happen that other thread already created a copy and mutated the original `_arguments` array.
             // In this case it's unsafe to replace it with a copy.
diff --git a/src/NSubstitute/Core/CustomHandlers.cs b/src/NSubstitute/Core/CustomHandlers.cs
@@ -2,7 +2,7 @@
 
 public class CustomHandlers : ICustomHandlers
 {
-    private readonly List<ICallHandler> _handlers = new();
+    private readonly List<ICallHandler> _handlers = [];
     private readonly ISubstituteState _substituteState;
 
     public IReadOnlyCollection<ICallHandler> Handlers => _handlers;
diff --git a/src/NSubstitute/Core/DependencyInjection/NSubContainer.cs b/src/NSubstitute/Core/DependencyInjection/NSubContainer.cs
@@ -17,7 +17,7 @@ public class NSubContainer : IConfigurableNSubContainer
 {
     private readonly NSubContainer? _parentContainer;
     private readonly object _syncRoot;
-    private readonly Dictionary<Type, Registration> _registrations = new();
+    private readonly Dictionary<Type, Registration> _registrations = [];
 
     public NSubContainer()
     {
@@ -177,7 +177,7 @@ public object Resolve(Scope scope)
 
     private class Scope : INSubResolver
     {
-        private readonly Dictionary<Registration, object> _cache = new Dictionary<Registration, object>();
+        private readonly Dictionary<Registration, object> _cache = [];
         private readonly NSubContainer _mostNestedContainer;
 
         public Scope(NSubContainer mostNestedContainer)
diff --git a/src/NSubstitute/Core/EventHandlerRegistry.cs b/src/NSubstitute/Core/EventHandlerRegistry.cs
@@ -6,7 +6,7 @@ public class EventHandlerRegistry : IEventHandlerRegistry
     // Events are not expected to be configured/raised concurrently, so simple locking should be sufficient.
     // List lookup is O(n), but for really small size performance is comparable to dictionary.
     // Given that normally a few events are configured only, it should be totally fine.
-    private readonly List<Tuple<string, List<object>>> _handlersForEvent = new();
+    private readonly List<Tuple<string, List<object>>> _handlersForEvent = [];
 
     public void Add(string eventName, object handler)
     {
diff --git a/src/NSubstitute/Core/Events/DelegateEventWrapper.cs b/src/NSubstitute/Core/Events/DelegateEventWrapper.cs
@@ -64,7 +64,7 @@ private bool LooksLikeAnEventStyleCall(ParameterInfo[] parameters)
             sender = _providedArguments[0];
             eventArgs = GetDefaultForEventArgType(eventArgsType);
         }
-        return new[] { sender, eventArgs };
+        return [sender, eventArgs];
     }
 
     private static bool RequiredArgsHaveBeenProvided(object?[] providedArgs, ParameterInfo[] requiredArgs)
diff --git a/src/NSubstitute/Core/Events/EventHandlerWrapper.cs b/src/NSubstitute/Core/Events/EventHandlerWrapper.cs
@@ -35,6 +35,6 @@ protected override object[] WorkOutRequiredArguments(ICall call)
     {
         var sender = _sender ?? call.Target();
         var eventArgs = _eventArgs ?? GetDefaultForEventArgType(typeof(TEventArgs));
-        return new[] { sender, eventArgs };
+        return [sender, eventArgs];
     }
 }
diff --git a/src/NSubstitute/Core/Events/RaiseEventWrapper.cs b/src/NSubstitute/Core/Events/RaiseEventWrapper.cs
@@ -21,7 +21,7 @@ protected EventArgs GetDefaultForEventArgType(Type type)
                 , type.Name, RaiseMethodName);
             throw new CannotCreateEventArgsException(message);
         }
-        return (EventArgs)defaultConstructor.Invoke(new object[0]);
+        return (EventArgs)defaultConstructor.Invoke([]);
     }
 
     private static ConstructorInfo? GetDefaultConstructor(Type type) => type.GetConstructor(Type.EmptyTypes);
diff --git a/src/NSubstitute/Core/Query.cs b/src/NSubstitute/Core/Query.cs
@@ -2,7 +2,7 @@
 
 public class Query : IQuery, IQueryResults
 {
-    private readonly List<CallSpecAndTarget> _querySpec = new();
+    private readonly List<CallSpecAndTarget> _querySpec = [];
     private readonly HashSet<ICall> _matchingCalls = new(new CallSequenceNumberComparer());
     private readonly ICallSpecificationFactory _callSpecificationFactory;
 
diff --git a/src/NSubstitute/Core/ReflectionExtensions.cs b/src/NSubstitute/Core/ReflectionExtensions.cs
@@ -41,8 +41,6 @@ private static bool CanBePropertySetterCall(MethodInfo call)
 
     private static PropertyInfo[] GetAllProperties(Type? type)
     {
-        return type != null
-            ? type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-            : new PropertyInfo[0];
+        return type?.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? [];
     }
 }
diff --git a/src/NSubstitute/Core/ThreadLocalContext.cs b/src/NSubstitute/Core/ThreadLocalContext.cs
@@ -6,7 +6,7 @@ namespace NSubstitute.Core;
 
 public class ThreadLocalContext : IThreadLocalContext
 {
-    private static readonly IArgumentSpecification[] EmptySpecifications = new IArgumentSpecification[0];
+    private static readonly IArgumentSpecification[] EmptySpecifications = [];
 
     private readonly RobustThreadLocal<ICallRouter?> _lastCallRouter;
     private readonly RobustThreadLocal<IList<IArgumentSpecification>> _argumentSpecifications;
diff --git a/src/NSubstitute/Extensions/ExceptionExtensions.cs b/src/NSubstitute/Extensions/ExceptionExtensions.cs
@@ -236,7 +236,7 @@ private static object FromException(object value, Exception exception)
         {
             var fromExceptionMethodInfo = typeof(Task).GetMethods(BindingFlags.Static | BindingFlags.Public).Single(m => m.Name == "FromException" && m.ContainsGenericParameters);
             var specificFromExceptionMethod = fromExceptionMethodInfo.MakeGenericMethod(valueType.GenericTypeArguments);
-            return specificFromExceptionMethod.Invoke(null, new object[] { exception });
+            return specificFromExceptionMethod.Invoke(null, [exception]);
         }
 
         return Task.FromException(exception);
diff --git a/src/NSubstitute/Proxies/CastleDynamicProxy/CastleDynamicProxyFactory.cs b/src/NSubstitute/Proxies/CastleDynamicProxy/CastleDynamicProxyFactory.cs
@@ -40,7 +40,7 @@ private object GenerateTypeProxy(ICallRouter callRouter, Type typeToProxy, Type[
             typeToProxy,
             additionalInterfaces,
             constructorArguments,
-            new IInterceptor[] { proxyIdInterceptor, forwardingInterceptor },
+            [proxyIdInterceptor, forwardingInterceptor],
             proxyGenerationOptions);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
@@ -63,7 +63,7 @@ private object GenerateDelegateProxy(ICallRouter callRouter, Type delegateType,
             typeToProxy: typeof(object),
             additionalInterfaces: null,
             constructorArguments: null,
-            interceptors: new IInterceptor[] { proxyIdInterceptor, forwardingInterceptor },
+            interceptors: [proxyIdInterceptor, forwardingInterceptor],
             proxyGenerationOptions);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
diff --git a/src/NSubstitute/Raise.cs b/src/NSubstitute/Raise.cs
@@ -81,7 +81,7 @@ private static object[] FixParamsArrayAmbiguity(object[] arguments, Type delegat
 
         if (singleParameterType.IsInstanceOfType(arguments))
         {
-            return new object[] { arguments };
+            return [arguments];
         }
 
         return arguments;
diff --git a/src/NSubstitute/Routing/AutoValues/AutoObservableProvider.cs b/src/NSubstitute/Routing/AutoValues/AutoObservableProvider.cs
@@ -1,5 +1,5 @@
-﻿using System.Reflection;
-using NSubstitute.Core;
+﻿using NSubstitute.Core;
+using System.Reflection;
 
 namespace NSubstitute.Routing.AutoValues;
 
@@ -23,9 +23,7 @@ public bool CanProvideValueFor(Type type) =>
         Type innerType = type.GetGenericArguments()[0];
         var valueProvider = _autoValueProviders.Value.FirstOrDefault(vp => vp.CanProvideValueFor(innerType));
         var value = valueProvider == null ? GetDefault(type) : valueProvider.GetValue(innerType);
-        return Activator.CreateInstance(
-                typeof(ReturnObservable<>).MakeGenericType(innerType)
-                , new object?[] { value });
+        return Activator.CreateInstance(typeof(ReturnObservable<>).MakeGenericType(innerType), [value]);
     }
 
     private static object? GetDefault(Type type)
diff --git a/src/NSubstitute/Routing/AutoValues/AutoSubstituteProvider.cs b/src/NSubstitute/Routing/AutoValues/AutoSubstituteProvider.cs
@@ -21,7 +21,7 @@ public bool CanProvideValueFor(Type type)
 
     public object GetValue(Type type)
     {
-        return _substituteFactory.Create(new[] { type }, new object[0]);
+        return _substituteFactory.Create([type], []);
     }
 
     private bool IsPureVirtualClassWithParameterlessConstructor(Type type)
diff --git a/src/NSubstitute/Routing/AutoValues/AutoTaskProvider.cs b/src/NSubstitute/Routing/AutoValues/AutoTaskProvider.cs
@@ -26,7 +26,7 @@ public object GetValue(Type type)
             var value = valueProvider == null ? GetDefault(type) : valueProvider.GetValue(taskType);
             var taskCompletionSourceType = typeof(TaskCompletionSource<>).MakeGenericType(taskType);
             var taskCompletionSource = Activator.CreateInstance(taskCompletionSourceType);
-            taskCompletionSourceType.GetMethod(nameof(TaskCompletionSource<object>.SetResult))!.Invoke(taskCompletionSource, new[] { value });
+            taskCompletionSourceType.GetMethod(nameof(TaskCompletionSource<object>.SetResult))!.Invoke(taskCompletionSource, [value]);
             return taskCompletionSourceType.GetProperty(nameof(TaskCompletionSource<object>.Task))!.GetValue(taskCompletionSource, null)!;
         }
         else
diff --git a/src/NSubstitute/Routing/AutoValues/AutoValueProvidersFactory.cs b/src/NSubstitute/Routing/AutoValues/AutoValueProvidersFactory.cs
@@ -12,15 +12,15 @@ public IReadOnlyCollection<IAutoValueProvider> CreateProviders(ISubstituteFactor
             () => result ?? throw new SubstituteInternalException("Value was not constructed yet."),
             LazyThreadSafetyMode.PublicationOnly);
 
-        result = new IAutoValueProvider[]
-        {
+        result =
+        [
             new AutoObservableProvider(lazyResult),
             new AutoQueryableProvider(),
             new AutoSubstituteProvider(substituteFactory),
             new AutoStringProvider(),
             new AutoArrayProvider(),
             new AutoTaskProvider(lazyResult)
-        };
+        ];
 
         return result;
     }
diff --git a/src/NSubstitute/Routing/RouteFactory.cs b/src/NSubstitute/Routing/RouteFactory.cs
@@ -30,85 +30,85 @@ public RouteFactory(SequenceNumberGenerator sequenceNumberGenerator,
 
     public IRoute CallQuery(ISubstituteState state)
     {
-        return new Route(new ICallHandler[] {
-            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new AddCallToQueryResultHandler(_threadLocalContext)
-            , new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new AddCallToQueryResultHandler(_threadLocalContext),
+            new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute CheckReceivedCalls(ISubstituteState state, MatchArgs matchArgs, Quantity requiredQuantity)
     {
-        return new Route(new ICallHandler[] {
-            new ClearLastCallRouterHandler(_threadLocalContext)
-            , new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new CheckReceivedCallsHandler(state.ReceivedCalls, _callSpecificationFactory, _receivedCallsExceptionThrower, matchArgs, requiredQuantity)
-            , new ReturnAutoValue(AutoValueBehaviour.ReturnAndForgetValue, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearLastCallRouterHandler(_threadLocalContext),
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new CheckReceivedCallsHandler(state.ReceivedCalls, _callSpecificationFactory, _receivedCallsExceptionThrower, matchArgs, requiredQuantity),
+            new ReturnAutoValue(AutoValueBehaviour.ReturnAndForgetValue, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute DoWhenCalled(ISubstituteState state, Action<CallInfo> doAction, MatchArgs matchArgs)
     {
-        return new Route(new ICallHandler[] {
-            new ClearLastCallRouterHandler(_threadLocalContext)
-            , new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new SetActionForCallHandler(_callSpecificationFactory, state.CallActions, doAction, matchArgs)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearLastCallRouterHandler(_threadLocalContext),
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new SetActionForCallHandler(_callSpecificationFactory, state.CallActions, doAction, matchArgs),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute DoNotCallBase(ISubstituteState state, MatchArgs matchArgs)
     {
-        return new Route(new ICallHandler[] {
-            new ClearLastCallRouterHandler(_threadLocalContext)
-            , new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new DoNotCallBaseForCallHandler(_callSpecificationFactory, state.CallBaseConfiguration, matchArgs)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearLastCallRouterHandler(_threadLocalContext),
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new DoNotCallBaseForCallHandler(_callSpecificationFactory, state.CallBaseConfiguration, matchArgs),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute CallBase(ISubstituteState state, MatchArgs matchArgs)
     {
-        return new Route(new ICallHandler[] {
-            new ClearLastCallRouterHandler(_threadLocalContext)
-            , new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new CallBaseForCallHandler(_callSpecificationFactory, state.CallBaseConfiguration, matchArgs)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearLastCallRouterHandler(_threadLocalContext),
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new CallBaseForCallHandler(_callSpecificationFactory, state.CallBaseConfiguration, matchArgs),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute RaiseEvent(ISubstituteState state, Func<ICall, object?[]> getEventArguments)
     {
-        return new Route(new ICallHandler[] {
-            new ClearLastCallRouterHandler(_threadLocalContext)
-            , new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification)
-            , new RaiseEventHandler(state.EventHandlerRegistry, getEventArguments)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new ClearLastCallRouterHandler(_threadLocalContext),
+            new ClearUnusedCallSpecHandler(_threadLocalContext.PendingSpecification),
+            new RaiseEventHandler(state.EventHandlerRegistry, getEventArguments),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute RecordCallSpecification(ISubstituteState state)
     {
-        return new Route(new ICallHandler[] {
-            new RecordCallSpecificationHandler(_threadLocalContext.PendingSpecification, _callSpecificationFactory, state.CallActions)
-            , new PropertySetterHandler(_propertyHelper, state.ConfigureCall)
-            , new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory)
-            , new ReturnFromAndConfigureDynamicCall(state.ConfigureCall)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new RecordCallSpecificationHandler(_threadLocalContext.PendingSpecification, _callSpecificationFactory, state.CallActions),
+            new PropertySetterHandler(_propertyHelper, state.ConfigureCall),
+            new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory),
+            new ReturnFromAndConfigureDynamicCall(state.ConfigureCall),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
     public IRoute RecordReplay(ISubstituteState state)
     {
-        return new Route(new ICallHandler[] {
-            new TrackLastCallHandler(_threadLocalContext.PendingSpecification)
-            , new RecordCallHandler(state.ReceivedCalls, _sequenceNumberGenerator)
-            , new EventSubscriptionHandler(state.EventHandlerRegistry)
-            , new PropertySetterHandler(_propertyHelper, state.ConfigureCall)
-            , new DoActionsCallHandler(state.CallActions)
-            , new ReturnConfiguredResultHandler(state.CallResults)
-            , new ReturnResultForTypeHandler(state.ResultsForType)
-            , new ReturnFromBaseIfRequired(state.CallBaseConfiguration)
-            , new ReturnFromCustomHandlers(state.CustomHandlers)
-            , new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory)
-            , new ReturnFromAndConfigureDynamicCall(state.ConfigureCall)
-            , ReturnDefaultForReturnTypeHandler()
-        });
+        return new Route([
+            new TrackLastCallHandler(_threadLocalContext.PendingSpecification),
+            new RecordCallHandler(state.ReceivedCalls, _sequenceNumberGenerator),
+            new EventSubscriptionHandler(state.EventHandlerRegistry),
+            new PropertySetterHandler(_propertyHelper, state.ConfigureCall),
+            new DoActionsCallHandler(state.CallActions),
+            new ReturnConfiguredResultHandler(state.CallResults),
+            new ReturnResultForTypeHandler(state.ResultsForType),
+            new ReturnFromBaseIfRequired(state.CallBaseConfiguration),
+            new ReturnFromCustomHandlers(state.CustomHandlers),
+            new ReturnAutoValue(AutoValueBehaviour.UseValueForSubsequentCalls, state.AutoValueProviders, state.AutoValuesCallResults, _callSpecificationFactory),
+            new ReturnFromAndConfigureDynamicCall(state.ConfigureCall),
+            ReturnDefaultForReturnTypeHandler()
+        ]);
     }
 
     private ReturnDefaultForReturnTypeHandler ReturnDefaultForReturnTypeHandler() => new(_defaultForType);
diff --git a/src/NSubstitute/Substitute.cs b/src/NSubstitute/Substitute.cs
diff --git a/src/NSubstitute/SubstituteExtensions.Returns.cs b/src/NSubstitute/SubstituteExtensions.Returns.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/ArgumentMatching.cs b/tests/NSubstitute.Acceptance.Specs/ArgumentMatching.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/ArgumentMatchingCompat.cs b/tests/NSubstitute.Acceptance.Specs/ArgumentMatchingCompat.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/FieldReports/ExceptionsThrownFromCustomArgumentMatchers.cs b/tests/NSubstitute.Acceptance.Specs/FieldReports/ExceptionsThrownFromCustomArgumentMatchers.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue47_RaisingEventsWithNullArg.cs b/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue47_RaisingEventsWithNullArg.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue500_SpecialMethodsWithoutAttribute.cs b/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue500_SpecialMethodsWithoutAttribute.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue560_RaiseEventWithArrayArg.cs b/tests/NSubstitute.Acceptance.Specs/FieldReports/Issue560_RaiseEventWithArrayArg.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/FormattingCallsWhenThrowingReceivedCallsExceptions.cs b/tests/NSubstitute.Acceptance.Specs/FormattingCallsWhenThrowingReceivedCallsExceptions.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/PartialSubExamples.cs b/tests/NSubstitute.Acceptance.Specs/PartialSubExamples.cs
diff --git a/tests/NSubstitute.Acceptance.Specs/ReceivedCalls.cs b/tests/NSubstitute.Acceptance.Specs/ReceivedCalls.cs

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace NSubstitute.Core;`
`5`	`5`
`6`	`6`	`public class ArgumentSpecificationDequeue : IArgumentSpecificationDequeue`
`7`	`7`	`{`
`8`		`- private static readonly IArgumentSpecification[] EmptySpecifications = new IArgumentSpecification[0];`
	`8`	`+ private static readonly IArgumentSpecification[] EmptySpecifications = [];`
`9`	`9`
`10`	`10`	`private readonly Func<IList<IArgumentSpecification>> _dequeueAllQueuedArgSpecs;`
`11`	`11`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public bool IsSatisfiedBy(object? argument)`
`31`	`31`
`32`	`32`	`public string Format(object? argument, bool highlight)`
`33`	`33`	`{`
`34`		`- var argArray = argument is IEnumerable enumerableArgs ? enumerableArgs.Cast<object>().ToArray() : new object[0];`
	`34`	`+ var argArray = argument is IEnumerable enumerableArgs ? enumerableArgs.Cast<object>().ToArray() : [];`
`35`	`35`	`return Format(argArray, _argumentSpecifications).Join(", ");`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ public void AssignSequenceNumber(long number)`
`81`	`81`	`object?[] originalArray = _originalArguments;`
`82`	`82`	`if (originalArray == _arguments && originalArray.Length > 0)`
`83`	`83`	`{`
`84`		`- object?[] copy = originalArray.ToArray();`
	`84`	`+ object?[] copy = [.. originalArray];`
`85`	`85`	// If it happens that _originalArguments doesn't point to the `_arguments` anymore -
`86`	`86`	// it might happen that other thread already created a copy and mutated the original `_arguments` array.
`87`	`87`	`// In this case it's unsafe to replace it with a copy.`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`public class CustomHandlers : ICustomHandlers`
`4`	`4`	`{`
`5`		`- private readonly List<ICallHandler> _handlers = new();`
	`5`	`+ private readonly List<ICallHandler> _handlers = [];`
`6`	`6`	`private readonly ISubstituteState _substituteState;`
`7`	`7`
`8`	`8`	`public IReadOnlyCollection<ICallHandler> Handlers => _handlers;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public class NSubContainer : IConfigurableNSubContainer`
`17`	`17`	`{`
`18`	`18`	`private readonly NSubContainer? _parentContainer;`
`19`	`19`	`private readonly object _syncRoot;`
`20`		`- private readonly Dictionary<Type, Registration> _registrations = new();`
	`20`	`+ private readonly Dictionary<Type, Registration> _registrations = [];`
`21`	`21`
`22`	`22`	`public NSubContainer()`
`23`	`23`	`{`
`@@ -177,7 +177,7 @@ public object Resolve(Scope scope)`
`177`	`177`
`178`	`178`	`private class Scope : INSubResolver`
`179`	`179`	`{`
`180`		`- private readonly Dictionary<Registration, object> _cache = new Dictionary<Registration, object>();`
	`180`	`+ private readonly Dictionary<Registration, object> _cache = [];`
`181`	`181`	`private readonly NSubContainer _mostNestedContainer;`
`182`	`182`
`183`	`183`	`public Scope(NSubContainer mostNestedContainer)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ public class EventHandlerRegistry : IEventHandlerRegistry`
`6`	`6`	`// Events are not expected to be configured/raised concurrently, so simple locking should be sufficient.`
`7`	`7`	`// List lookup is O(n), but for really small size performance is comparable to dictionary.`
`8`	`8`	`// Given that normally a few events are configured only, it should be totally fine.`
`9`		`- private readonly List<Tuple<string, List<object>>> _handlersForEvent = new();`
	`9`	`+ private readonly List<Tuple<string, List<object>>> _handlersForEvent = [];`
`10`	`10`
`11`	`11`	`public void Add(string eventName, object handler)`
`12`	`12`	`{`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ private bool LooksLikeAnEventStyleCall(ParameterInfo[] parameters)`
`64`	`64`	`sender = _providedArguments[0];`
`65`	`65`	`eventArgs = GetDefaultForEventArgType(eventArgsType);`
`66`	`66`	`}`
`67`		`- return new[] { sender, eventArgs };`
	`67`	`+ return [sender, eventArgs];`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`private static bool RequiredArgsHaveBeenProvided(object?[] providedArgs, ParameterInfo[] requiredArgs)`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,6 @@ protected override object[] WorkOutRequiredArguments(ICall call)`
`35`	`35`	`{`
`36`	`36`	`var sender = _sender ?? call.Target();`
`37`	`37`	`var eventArgs = _eventArgs ?? GetDefaultForEventArgType(typeof(TEventArgs));`
`38`		`- return new[] { sender, eventArgs };`
	`38`	`+ return [sender, eventArgs];`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ protected EventArgs GetDefaultForEventArgType(Type type)`
`21`	`21`	`, type.Name, RaiseMethodName);`
`22`	`22`	`throw new CannotCreateEventArgsException(message);`
`23`	`23`	`}`
`24`		`- return (EventArgs)defaultConstructor.Invoke(new object[0]);`
	`24`	`+ return (EventArgs)defaultConstructor.Invoke([]);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`private static ConstructorInfo? GetDefaultConstructor(Type type) => type.GetConstructor(Type.EmptyTypes);`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`public class Query : IQuery, IQueryResults`
`4`	`4`	`{`
`5`		`- private readonly List<CallSpecAndTarget> _querySpec = new();`
	`5`	`+ private readonly List<CallSpecAndTarget> _querySpec = [];`
`6`	`6`	`private readonly HashSet<ICall> _matchingCalls = new(new CallSequenceNumberComparer());`
`7`	`7`	`private readonly ICallSpecificationFactory _callSpecificationFactory;`
`8`	`8`