Simplify collection initialization with expressions

atifaziz · atifaziz · commit 7289b2322a5e · 2025-03-16T22:28:30.000+01:00
Addresses "Collection initialization can be simplified": - IDE0028 <https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0028> - IDE0303 <https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0303> - IDE0305 <https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0305> - IDE0306 <https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0306>
diff --git a/MoreLinq.Test.Aot/ToDataTableTest.cs b/MoreLinq.Test.Aot/ToDataTableTest.cs
@@ -45,9 +45,8 @@ sealed class TestObject(int key)
         readonly ImmutableArray<TestObject> testObjects;
 
         public ToDataTableTest() =>
-            this.testObjects = Enumerable.Range(0, 3)
-                                         .Select(i => new TestObject(i))
-                                         .ToImmutableArray();
+            this.testObjects = [..from i in Enumerable.Range(0, 3)
+                                  select new TestObject(i)];
 
         [TestMethod]
         public void ToDataTableNullMemberExpressionMethod()
diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs
@@ -51,9 +51,8 @@ from m in typeof(MoreEnumerable).GetMethods(BindingFlags.Public | BindingFlags.S
             {
                 Source = source,
                 Expectation = sum,
-                Instantiation = m.MakeGenericMethod(Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1)
-                                                              .Append(typeof(int[])) // TResult
-                                                              .ToArray()),
+                Instantiation = m.MakeGenericMethod([..Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1)
+                                                                 .Append(typeof(int[]))]), // TResult
             }
             into m
             let rst = m.Instantiation.GetParameters().Last().ParameterType
diff --git a/MoreLinq.Test/BacksertTest.cs b/MoreLinq.Test/BacksertTest.cs
@@ -57,7 +57,7 @@ public IEnumerable<int> Backsert(int[] seq1, int index, int[] seq2)
             using var test1 = seq1.AsTestingSequence();
             using var test2 = seq2.AsTestingSequence();
 
-            return test1.Backsert(test2, index).ToArray();
+            return [..test1.Backsert(test2, index)];
         }
     }
 }
diff --git a/MoreLinq.Test/CartesianTest.cs b/MoreLinq.Test/CartesianTest.cs
@@ -17,6 +17,7 @@
 
 namespace MoreLinq.Test
 {
+    using System;
     using NUnit.Framework;
 
     /// <summary>
@@ -122,14 +123,14 @@ public void TestCartesianProductCombinations()
             var sequenceA = Enumerable.Range(0, 5);
             var sequenceB = Enumerable.Range(0, 5);
 
-            var expectedSet = new[]
-            {
-                Enumerable.Repeat(false, 5).ToArray(),
-                Enumerable.Repeat(false, 5).ToArray(),
-                Enumerable.Repeat(false, 5).ToArray(),
-                Enumerable.Repeat(false, 5).ToArray(),
-                Enumerable.Repeat(false, 5).ToArray()
-            };
+            bool[][] expectedSet =
+            [
+                [..Enumerable.Repeat(false, 5)],
+                [..Enumerable.Repeat(false, 5)],
+                [..Enumerable.Repeat(false, 5)],
+                [..Enumerable.Repeat(false, 5)],
+                [..Enumerable.Repeat(false, 5)],
+            ];
 
             using var tsA = sequenceA.AsTestingSequence();
             using var tsB = sequenceB.AsTestingSequence();
diff --git a/MoreLinq.Test/FullGroupJoinTest.cs b/MoreLinq.Test/FullGroupJoinTest.cs
@@ -126,8 +126,8 @@ public void FullGroupPreservesOrder(OverloadCase overloadCase)
             // Order of joined elements is preserved
             foreach (var (key, first, second) in result)
             {
-                first.AssertSequenceEqual(listA.Where(t => t.Item1 == key).ToArray());
-                second.AssertSequenceEqual(listB.Where(t => t.Item1 == key).ToArray());
+                first.AssertSequenceEqual([..from t in listA where t.Item1 == key select t]);
+                second.AssertSequenceEqual([..from t in listB where t.Item1 == key select t]);
             }
         }
 
diff --git a/MoreLinq.Test/MaximaTest.cs b/MoreLinq.Test/MaximaTest.cs
@@ -213,7 +213,7 @@ public class Take
             public string[] ReturnsMaxima(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Maxima(s => s.Length).Take(count).ToArray();
+                return [..strings.Maxima(s => s.Length).Take(count)];
             }
 
             [TestCase(0, 0, ExpectedResult = new string[0]                         )]
@@ -227,9 +227,8 @@ public string[] ReturnsMaxima(int count)
             public string[] WithComparerReturnsMaximaPerComparer(int count, int index)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)
-                              .Take(count)
-                              .ToArray();
+                return [..strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)
+                                 .Take(count)];
             }
         }
 
@@ -242,7 +241,7 @@ public class TakeLast
             public string[] TakeLastReturnsMaxima(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Maxima(s => s.Length).TakeLast(count).ToArray();
+                return [..strings.Maxima(s => s.Length).TakeLast(count)];
             }
 
             [TestCase(0, 0, ExpectedResult = new string[0]                         )]
@@ -256,9 +255,8 @@ public string[] TakeLastReturnsMaxima(int count)
             public string[] WithComparerReturnsMaximaPerComparer(int count, int index)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)
-                              .TakeLast(count)
-                              .ToArray();
+                return [..strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)
+                                 .TakeLast(count)];
             }
         }
     }
diff --git a/MoreLinq.Test/MinimaTest.cs b/MoreLinq.Test/MinimaTest.cs
@@ -212,7 +212,7 @@ public class Take
             public string[] ReturnsMinima(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Minima(s => s.Length).Take(count).ToArray();
+                return [..strings.Minima(s => s.Length).Take(count)];
             }
 
             [TestCase(0, ExpectedResult = new string[0]             )]
@@ -222,9 +222,8 @@ public string[] ReturnsMinima(int count)
             public string[] WithComparerReturnsMinimaPerComparer(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)
-                              .Take(count)
-                              .ToArray();
+                return [..strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)
+                                 .Take(count)];
             }
         }
 
@@ -240,7 +239,7 @@ public class TakeLast
             public string[] ReturnsMinima(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Minima(s => s.Length).TakeLast(count).ToArray();
+                return [..strings.Minima(s => s.Length).TakeLast(count)];
             }
 
             [TestCase(0, ExpectedResult = new string[0]             )]
@@ -250,9 +249,8 @@ public string[] ReturnsMinima(int count)
             public string[] WithComparerReturnsMinimaPerComparer(int count)
             {
                 using var strings = SampleData.Strings.AsTestingSequence();
-                return strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)
-                              .TakeLast(count)
-                              .ToArray();
+                return [..strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)
+                                 .TakeLast(count)];
             }
         }
     }
diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs
@@ -103,7 +103,7 @@ var constraints when constraints.Any(t => t.IsGenericType && t.GetGenericTypeDef
                     _ => throw new NotImplementedException("NullArgumentTest.InstantiateType")
                 };
 
-            return definition.MakeGenericMethod(typeArguments.ToArray());
+            return definition.MakeGenericMethod([..typeArguments]);
         }
 
         static bool IsReferenceType(ParameterInfo parameter) =>
diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs
@@ -60,7 +60,7 @@ public void PrependIsLazyInTailSequence()
         [TestCaseSource(nameof(PrependManySource))]
         public int[] PrependMany(int[] head, int[] tail)
         {
-            return tail.Aggregate(head.AsEnumerable(), MoreEnumerable.Prepend).ToArray();
+            return [..tail.Aggregate(head.AsEnumerable(), MoreEnumerable.Prepend)];
         }
 
         public static IEnumerable<TestCaseData> PrependManySource =>
diff --git a/MoreLinq.Test/RepeatTest.cs b/MoreLinq.Test/RepeatTest.cs
@@ -46,7 +46,7 @@ public void TestRepeatBehavior()
 
             int[] result;
             using (var ts = sequence.AsTestingSequence())
-                result = ts.Repeat(repeatCount).ToArray();
+                result = [..ts.Repeat(repeatCount)];
 
             var expectedResult = Enumerable.Empty<int>();
             for (var i = 0; i < repeatCount; i++)
@@ -94,7 +94,7 @@ public void TestRepeatForeverBehaviorManyElementsList()
 
             int[] result;
             using (var ts = sequence.AsTestingSequence())
-                result = ts.Repeat().Take(takeCount).ToArray();
+                result = [..ts.Repeat().Take(takeCount)];
 
             var expectedResult = Enumerable.Empty<int>();
             for (var i = 0; i < repeatCount; i++)
diff --git a/MoreLinq.Test/SkipUntilTest.cs b/MoreLinq.Test/SkipUntilTest.cs
@@ -77,7 +77,7 @@ from e in new[]
         public int[] TestSkipUntil(int[] source, int min)
         {
             using var ts = source.AsTestingSequence();
-            return ts.SkipUntil(v => v >= min).ToArray();
+            return [..ts.SkipUntil(v => v >= min)];
         }
     }
 }
diff --git a/MoreLinq.Test/SplitTest.cs b/MoreLinq.Test/SplitTest.cs
@@ -25,14 +25,14 @@ public class SplitTest
         [Test]
         public void SplitWithSeparatorAndResultTransformation()
         {
-            var result = "the quick brown fox".ToCharArray().Split(' ', chars => new string(chars.ToArray()));
+            var result = "the quick brown fox".ToCharArray().Split(' ', chars => new string([..chars]));
             result.AssertSequenceEqual("the", "quick", "brown", "fox");
         }
 
         [Test]
         public void SplitUptoMaxCount()
         {
-            var result = "the quick brown fox".ToCharArray().Split(' ', 2, chars => new string(chars.ToArray()));
+            var result = "the quick brown fox".ToCharArray().Split(' ', 2, chars => new string([..chars]));
             result.AssertSequenceEqual("the", "quick", "brown fox");
         }
 
diff --git a/MoreLinq.Test/TestExtensions.cs b/MoreLinq.Test/TestExtensions.cs
@@ -97,10 +97,12 @@ internal static IEnumerable<T> AsSourceKind<T>(this List<T> input, SourceKind so
             sourceKind switch
             {
                 SourceKind.Sequence => input.Select(x => x),
+#pragma warning disable IDE0028 // Simplify collection initialization (would change semantics)
                 SourceKind.BreakingList => new BreakingList<T>(input),
                 SourceKind.BreakingReadOnlyList => new BreakingReadOnlyList<T>(input),
                 SourceKind.BreakingCollection => new BreakingCollection<T>(input),
                 SourceKind.BreakingReadOnlyCollection => new BreakingReadOnlyCollection<T>(input),
+#pragma warning restore IDE0028 // Simplify collection initialization
                 _ => throw new ArgumentException(null, nameof(sourceKind))
             };
     }
diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs
@@ -44,9 +44,22 @@ sealed class TestObject(int key)
         readonly ImmutableArray<TestObject> testObjects;
 
         public ToDataTableTest() =>
-            this.testObjects = Enumerable.Range(0, 3)
-                                         .Select(i => new TestObject(i))
-                                         .ToImmutableArray();
+            this.testObjects =
+#if NET8_0_OR_GREATER
+                [..
+#else
+#pragma warning disable IDE0303 // Use array creation expression
+                ImmutableArray.CreateRange(
+#pragma warning restore IDE0303 // Use array creation expression
+#endif
+                    from i in Enumerable.Range(0, 3)
+                    select new TestObject(i)
+#if NET8_0_OR_GREATER
+                ]
+#else
+                )
+#endif
+                ;
 
         [Test]
         public void ToDataTableNullMemberExpressionMethod()
diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs
@@ -93,7 +93,7 @@ public void WindowLeftWithSingleElement()
 
             IList<int>[] result;
             using (var ts = sequence.AsTestingSequence())
-                result = ts.WindowLeft(1).ToArray();
+                result = [..ts.WindowLeft(1)];
 
             // number of windows should be equal to the source sequence length
             Assert.That(result.Length, Is.EqualTo(count));
diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs
@@ -93,7 +93,7 @@ public void WindowRightWithSingleElement()
 
             IList<int>[] result;
             using (var ts = sequence.AsTestingSequence())
-                result = ts.WindowRight(1).ToArray();
+                result = [..ts.WindowRight(1)];
 
             // number of windows should be equal to the source sequence length
             Assert.That(result.Length, Is.EqualTo(count));
diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs
@@ -45,7 +45,7 @@ from e in new[]
         {
             using var ts1 = first.AsTestingSequence();
             using var ts2 = second.AsTestingSequence();
-            return ts1.ZipLongest(ts2, Tuple.Create).ToArray();
+            return [..ts1.ZipLongest(ts2, Tuple.Create)];
         }
 
         [Test]
diff --git a/MoreLinq/EndsWith.cs b/MoreLinq/EndsWith.cs
@@ -75,7 +75,7 @@ public static bool EndsWith<T>(this IEnumerable<T> first, IEnumerable<T> second,
             return second.TryAsCollectionLike() is { Count: var secondCount }
                    ? first.TryAsCollectionLike() is not { Count: var firstCount } || secondCount <= firstCount
                      && EndsWith(second, secondCount)
-                   : EndsWith(secondList = second.ToList(), secondList.Count);
+                   : EndsWith(secondList = [..second], secondList.Count);
 
             bool EndsWith(IEnumerable<T> second, int count) =>
                 first.TakeLast(count).SequenceEqual(second, comparer);
diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs
@@ -58,7 +58,9 @@ public static IEnumerable<T> Memoize<T>(this IEnumerable<T> source) =>
                 ICollection<T> => source,
                 IReadOnlyCollection<T> => source,
                 MemoizedEnumerable<T> => source,
+#pragma warning disable IDE0306 // Simplify collection initialization (would change semantics)
                 _ => new MemoizedEnumerable<T>(source),
+#pragma warning restore IDE0306 // Simplify collection initialization
             };
     }
 
diff --git a/MoreLinq/Rank.cs b/MoreLinq/Rank.cs
@@ -81,7 +81,9 @@ public static IEnumerable<int> RankBy<TSource, TKey>(this IEnumerable<TSource> s
 
             static IEnumerable<int> _(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
             {
+#pragma warning disable IDE0305 // Simplify collection initialization (could be less optimal)
                 source = source.ToArray(); // avoid enumerating source twice
+#pragma warning restore IDE0305 // Simplify collection initialization
 
                 var rankDictionary = new Collections.Dictionary<TSource, int>(EqualityComparer<TSource>.Default);
                 var i = 1;
diff --git a/MoreLinq/SortedMerge.cs b/MoreLinq/SortedMerge.cs
@@ -158,7 +158,7 @@ static IEnumerable<TSource> Impl(IEnumerable<IEnumerable<TSource>> sequences, Fu
 
         sealed class DisposableGroup<T>(IEnumerable<IEnumerator<T>> iterators) : IDisposable
         {
-            public List<IEnumerator<T>> Iterators { get; } = new(iterators);
+            public List<IEnumerator<T>> Iterators { get; } = [..iterators];
 
             public IEnumerator<T> this[int index] => Iterators[index];
 
diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs
@@ -171,7 +171,7 @@ static MemberInfo[] PrepareMemberInfos<T>(ICollection<Expression<Func<T, object?
                 throw new ArgumentException("One of the supplied expressions was null.", nameof(expressions));
             try
             {
-                return expressions.Select(GetAccessedMember).ToArray();
+                return [..from e in expressions select GetAccessedMember(e)];
             }
             catch (ArgumentException e)
             {
diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs
@@ -155,14 +155,14 @@ from e in ms.Select((m, i) => (SourceOrder: i + 1, Method: m))
             e.Method.Name,
             e.Method.TypeParameterCount,
             e.Method.ParameterCount,
-            new TupleTypeKey(ImmutableList.CreateRange(e.Method.SortableParameterTypes))
+            new TupleTypeKey([..e.Method.SortableParameterTypes])
         select new
         {
             e.Method,
             e.SourceOrder,
         };
 
-    q = q.ToArray();
+    q = [..q];
 
     if (args.OptDebug)
     {
@@ -336,14 +336,12 @@ static TypeKey CreateTypeKey(TypeSyntax root, Func<string, TypeKey?> abbreviator
                                     ?? new SimpleTypeKey(ins.ToString()),
         GenericNameSyntax gns =>
             new GenericTypeKey(gns.Identifier.ToString(),
-                               ImmutableList.CreateRange(gns.TypeArgumentList.Arguments.Select(Walk))),
+                               [..from arg in gns.TypeArgumentList.Arguments select Walk(arg)]),
         ArrayTypeSyntax ats =>
             new ArrayTypeKey(Walk(ats.ElementType),
-                             ImmutableList.CreateRange(from rs in ats.RankSpecifiers
-                                                       select rs.Rank)),
+                             [..from rs in ats.RankSpecifiers select rs.Rank]),
         TupleTypeSyntax tts =>
-            new TupleTypeKey(ImmutableList.CreateRange(from te in tts.Elements
-                                                       select Walk(te.Type))),
+            new TupleTypeKey([..from te in tts.Elements select Walk(te.Type)]),
         _ => throw new NotSupportedException("Unhandled type: " + ts)
     };
 }
@@ -415,7 +413,7 @@ public override string ToString() =>
 sealed class ArrayTypeKey(TypeKey element, IEnumerable<int> ranks) :
     ParameterizedTypeKey("[]", element)
 {
-    public ImmutableList<int> Ranks { get; } = ImmutableList.CreateRange(ranks);
+    public ImmutableList<int> Ranks { get; } = [..ranks];
 
     public override string ToString() =>
         Parameters.Single() + string.Concat(from r in Ranks

Original file line number	Diff line number	Diff line change
`@@ -51,9 +51,8 @@ from m in typeof(MoreEnumerable).GetMethods(BindingFlags.Public \| BindingFlags.S`
`51`	`51`	`{`
`52`	`52`	`Source = source,`
`53`	`53`	`Expectation = sum,`
`54`		`- Instantiation = m.MakeGenericMethod(Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1)`
`55`		`- .Append(typeof(int[])) // TResult`
`56`		`- .ToArray()),`
	`54`	`+ Instantiation = m.MakeGenericMethod([..Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1)`
	`55`	`+ .Append(typeof(int[]))]), // TResult`
`57`	`56`	`}`
`58`	`57`	`into m`
`59`	`58`	`let rst = m.Instantiation.GetParameters().Last().ParameterType`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public IEnumerable<int> Backsert(int[] seq1, int index, int[] seq2)`
`57`	`57`	`using var test1 = seq1.AsTestingSequence();`
`58`	`58`	`using var test2 = seq2.AsTestingSequence();`
`59`	`59`
`60`		`- return test1.Backsert(test2, index).ToArray();`
	`60`	`+ return [..test1.Backsert(test2, index)];`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -126,8 +126,8 @@ public void FullGroupPreservesOrder(OverloadCase overloadCase)`
`126`	`126`	`// Order of joined elements is preserved`
`127`	`127`	`foreach (var (key, first, second) in result)`
`128`	`128`	`{`
`129`		`- first.AssertSequenceEqual(listA.Where(t => t.Item1 == key).ToArray());`
`130`		`- second.AssertSequenceEqual(listB.Where(t => t.Item1 == key).ToArray());`
	`129`	`+ first.AssertSequenceEqual([..from t in listA where t.Item1 == key select t]);`
	`130`	`+ second.AssertSequenceEqual([..from t in listB where t.Item1 == key select t]);`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ public class Take`
`213`	`213`	`public string[] ReturnsMaxima(int count)`
`214`	`214`	`{`
`215`	`215`	`using var strings = SampleData.Strings.AsTestingSequence();`
`216`		`- return strings.Maxima(s => s.Length).Take(count).ToArray();`
	`216`	`+ return [..strings.Maxima(s => s.Length).Take(count)];`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`[TestCase(0, 0, ExpectedResult = new string[0] )]`
`@@ -227,9 +227,8 @@ public string[] ReturnsMaxima(int count)`
`227`	`227`	`public string[] WithComparerReturnsMaximaPerComparer(int count, int index)`
`228`	`228`	`{`
`229`	`229`	`using var strings = SampleData.Strings.AsTestingSequence();`
`230`		`- return strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)`
`231`		`- .Take(count)`
`232`		`- .ToArray();`
	`230`	`+ return [..strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)`
	`231`	`+ .Take(count)];`
`233`	`232`	`}`
`234`	`233`	`}`
`235`	`234`
`@@ -242,7 +241,7 @@ public class TakeLast`
`242`	`241`	`public string[] TakeLastReturnsMaxima(int count)`
`243`	`242`	`{`
`244`	`243`	`using var strings = SampleData.Strings.AsTestingSequence();`
`245`		`- return strings.Maxima(s => s.Length).TakeLast(count).ToArray();`
	`244`	`+ return [..strings.Maxima(s => s.Length).TakeLast(count)];`
`246`	`245`	`}`
`247`	`246`
`248`	`247`	`[TestCase(0, 0, ExpectedResult = new string[0] )]`
`@@ -256,9 +255,8 @@ public string[] TakeLastReturnsMaxima(int count)`
`256`	`255`	`public string[] WithComparerReturnsMaximaPerComparer(int count, int index)`
`257`	`256`	`{`
`258`	`257`	`using var strings = SampleData.Strings.AsTestingSequence();`
`259`		`- return strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)`
`260`		`- .TakeLast(count)`
`261`		`- .ToArray();`
	`258`	`+ return [..strings.Maxima(s => s[index], Comparable<char>.DescendingOrderComparer)`
	`259`	`+ .TakeLast(count)];`
`262`	`260`	`}`
`263`	`261`	`}`
`264`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,7 @@ public class Take`
`212`	`212`	`public string[] ReturnsMinima(int count)`
`213`	`213`	`{`
`214`	`214`	`using var strings = SampleData.Strings.AsTestingSequence();`
`215`		`- return strings.Minima(s => s.Length).Take(count).ToArray();`
	`215`	`+ return [..strings.Minima(s => s.Length).Take(count)];`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`[TestCase(0, ExpectedResult = new string[0] )]`
`@@ -222,9 +222,8 @@ public string[] ReturnsMinima(int count)`
`222`	`222`	`public string[] WithComparerReturnsMinimaPerComparer(int count)`
`223`	`223`	`{`
`224`	`224`	`using var strings = SampleData.Strings.AsTestingSequence();`
`225`		`- return strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)`
`226`		`- .Take(count)`
`227`		`- .ToArray();`
	`225`	`+ return [..strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)`
	`226`	`+ .Take(count)];`
`228`	`227`	`}`
`229`	`228`	`}`
`230`	`229`
`@@ -240,7 +239,7 @@ public class TakeLast`
`240`	`239`	`public string[] ReturnsMinima(int count)`
`241`	`240`	`{`
`242`	`241`	`using var strings = SampleData.Strings.AsTestingSequence();`
`243`		`- return strings.Minima(s => s.Length).TakeLast(count).ToArray();`
	`242`	`+ return [..strings.Minima(s => s.Length).TakeLast(count)];`
`244`	`243`	`}`
`245`	`244`
`246`	`245`	`[TestCase(0, ExpectedResult = new string[0] )]`
`@@ -250,9 +249,8 @@ public string[] ReturnsMinima(int count)`
`250`	`249`	`public string[] WithComparerReturnsMinimaPerComparer(int count)`
`251`	`250`	`{`
`252`	`251`	`using var strings = SampleData.Strings.AsTestingSequence();`
`253`		`- return strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)`
`254`		`- .TakeLast(count)`
`255`		`- .ToArray();`
	`252`	`+ return [..strings.Minima(s => s.Length, Comparable<int>.DescendingOrderComparer)`
	`253`	`+ .TakeLast(count)];`
`256`	`254`	`}`
`257`	`255`	`}`
`258`	`256`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ var constraints when constraints.Any(t => t.IsGenericType && t.GetGenericTypeDef`
`103`	`103`	`_ => throw new NotImplementedException("NullArgumentTest.InstantiateType")`
`104`	`104`	`};`
`105`	`105`
`106`		`- return definition.MakeGenericMethod(typeArguments.ToArray());`
	`106`	`+ return definition.MakeGenericMethod([..typeArguments]);`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`static bool IsReferenceType(ParameterInfo parameter) =>`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public void PrependIsLazyInTailSequence()`
`60`	`60`	`[TestCaseSource(nameof(PrependManySource))]`
`61`	`61`	`public int[] PrependMany(int[] head, int[] tail)`
`62`	`62`	`{`
`63`		`- return tail.Aggregate(head.AsEnumerable(), MoreEnumerable.Prepend).ToArray();`
	`63`	`+ return [..tail.Aggregate(head.AsEnumerable(), MoreEnumerable.Prepend)];`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`public static IEnumerable<TestCaseData> PrependManySource =>`