Revamp empty special-casing in LINQ (dotnet#96602)

* Revamp empty special-casing in LINQ

Enumerable.Empty used to return Array.Empty. Towards the beginning of .NET Core, LINQ was imbued with an internal "partition" concept for flowing more information around between operators, and as part of that, Empty was changed to return a singleton instance of a specialized partition implementation. The upside of this was that methods typed to return IPartition could return the same singleton as Empty. There are multiple downsides, however. For one, the whole IPartition concept is only built into a "speed-optimized" build of LINQ; builds that care more about size (e.g. browser) end up not having it, and thus Empty there ends up being Array.Empty, such that a different type ends up being returned based on the build, which is not ideal. Further, any paths that check for empty now effectively have two things to check for: the empty partition or an empty array, making those checks more expensive, if they're even done at all, or in some cases missing out on possible optimization. This is more pronounced today, now that `[]` with collection expressions will produce Array.Empty, and it'd be really nice if there wasn't a difference between Enumerable.Empty and `[]` assigned to `IEnumerable<T>`.

This change puts Enumerable.Empty back to always being Array.Empty. The internal IPartition-based APIs that drove us to need the EmptyPartition are changed to just use null as an indication of empty. Places we were already checking for `is EmptyPartition` are changed to check for an empty array (if they weren't already), and other APIs that weren't checking at all now have a check if it makes sense to do so (I audited all of the APIs, and didn't include checks in ones where it could meaningfully affect semantics, e.g. a fast path that might cause us not to get an enumerator from a secondary enumerable input).

* Rename IsImmutableEmpty to IsEmptyArray per PR feedback

* Remove bogus PLINQ tests

The tests were validating the underlying type of the operator returned for Concat, which is not material.

* Fix Skip special-casing

The check needs to be moved to before the count <= 0 check... otherwise calling Skip on an empty array with a count of 0 would still allocate an iterator.

Author: stephentoub

src/libraries/System.Linq.Parallel/tests/QueryOperators/AsEnumerableTests.cs

@@ -57,7 +57,6 @@ public static void AsEnumerable_LinqBinding(Labeled<ParallelQuery<int>> labeled,
             Assert.IsNotType<ParallelQuery<int>>(enumerable.Cast<int>());
             Assert.True(enumerable.Cast<int>() is ParallelQuery<int>);
 
-            Assert.False(enumerable.Concat(Enumerable.Range(0, count)) is ParallelQuery<int>);
             Assert.False(enumerable.DefaultIfEmpty() is ParallelQuery<int>);
             Assert.False(enumerable.Distinct() is ParallelQuery<int>);
             Assert.False(enumerable.Except(Enumerable.Range(0, count)) is ParallelQuery<int>);

src/libraries/System.Linq.Parallel/tests/QueryOperators/AsSequentialTests.cs

@@ -57,7 +57,6 @@ public static void AsSequential_LinqBinding(Labeled<ParallelQuery<int>> labeled,
             Assert.IsNotType<ParallelQuery<int>>(seq.Cast<int>());
             Assert.True(seq.Cast<int>() is ParallelQuery<int>);
 
-            Assert.False(seq.Concat(Enumerable.Range(0, count)) is ParallelQuery<int>);
             Assert.False(seq.DefaultIfEmpty() is ParallelQuery<int>);
             Assert.False(seq.Distinct() is ParallelQuery<int>);
             Assert.False(seq.Except(Enumerable.Range(0, count)) is ParallelQuery<int>);

src/libraries/System.Linq/src/System.Linq.csproj

@@ -12,7 +12,6 @@
   </PropertyGroup>
 
   <ItemGroup Condition="'$(OptimizeForSize)' == true">
-    <Compile Include="System\Linq\Enumerable.SizeOpt.cs" />
     <Compile Include="System\Linq\Skip.SizeOpt.cs" />
     <Compile Include="System\Linq\Take.SizeOpt.cs" />
     <Compile Include="$(CommonPath)\System\Collections\Generic\LargeArrayBuilder.SizeOpt.cs"
@@ -24,7 +23,6 @@
     <Compile Include="System\Linq\Concat.SpeedOpt.cs" />
     <Compile Include="System\Linq\DefaultIfEmpty.SpeedOpt.cs" />
     <Compile Include="System\Linq\Distinct.SpeedOpt.cs" />
-    <Compile Include="System\Linq\Enumerable.SpeedOpt.cs" />
     <Compile Include="System\Linq\Grouping.SpeedOpt.cs" />
     <Compile Include="System\Linq\Lookup.SpeedOpt.cs" />
     <Compile Include="System\Linq\OrderedEnumerable.SpeedOpt.cs" />

src/libraries/System.Linq/src/System/Linq/AggregateBy.cs

@@ -28,6 +28,11 @@ public static IEnumerable<KeyValuePair<TKey, TAccumulate>> AggregateBy<TSource,
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.func);
             }
 
+            if (IsEmptyArray(source))
+            {
+                return [];
+            }
+
             return AggregateByIterator(source, keySelector, seed, func, keyComparer);
         }
 
@@ -55,6 +60,11 @@ public static IEnumerable<KeyValuePair<TKey, TAccumulate>> AggregateBy<TSource,
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.func);
             }
 
+            if (IsEmptyArray(source))
+            {
+                return [];
+            }
+
             return AggregateByIterator(source, keySelector, seedSelector, func, keyComparer);
         }
 

src/libraries/System.Linq/src/System/Linq/Chunk.cs

@@ -3,8 +3,6 @@
 
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
 
 namespace System.Linq
 {
@@ -47,6 +45,11 @@ public static IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> so
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.size);
             }
 
+            if (IsEmptyArray(source))
+            {
+                return [];
+            }
+
             return ChunkIterator(source, size);
         }
 

src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs

@@ -150,7 +150,7 @@ private TSource[] PreallocatingToArray()
 
                 if (count == 0)
                 {
-                    return Array.Empty<TSource>();
+                    return [];
                 }
 
                 var array = new TSource[count];

src/libraries/System.Linq/src/System/Linq/Concat.cs

@@ -20,6 +20,16 @@ public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> fir
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.second);
             }
 
+            if (IsEmptyArray(first))
+            {
+                return second;
+            }
+
+            if (IsEmptyArray(second))
+            {
+                return first;
+            }
+
             return first is ConcatIterator<TSource> firstConcat
                 ? firstConcat.Concat(second)
                 : new Concat2Iterator<TSource>(first, second);

src/libraries/System.Linq/src/System/Linq/CountBy.cs

@@ -19,6 +19,11 @@ public static IEnumerable<KeyValuePair<TKey, int>> CountBy<TSource, TKey>(this I
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.keySelector);
             }
 
+            if (IsEmptyArray(source))
+            {
+                return [];
+            }
+
             return CountByIterator(source, keySelector, keyComparer);
         }
 

src/libraries/System.Linq/src/System/Linq/DebugView.cs

@@ -76,11 +76,7 @@ public object?[] Items
         {
             get
             {
-                var tempList = new List<object?>();
-                foreach (object? item in _enumerable)
-                {
-                    tempList.Add(item);
-                }
+                List<object?> tempList = [.. _enumerable];
 
                 if (tempList.Count == 0)
                 {
@@ -114,10 +110,10 @@ public SystemLinq_GroupingDebugView(Grouping<TKey, TElement> grouping)
 
     internal sealed class SystemLinq_LookupDebugView<TKey, TElement>
     {
-        private readonly Lookup<TKey, TElement> _lookup;
+        private readonly ILookup<TKey, TElement> _lookup;
         private IGrouping<TKey, TElement>[]? _cachedGroupings;
 
-        public SystemLinq_LookupDebugView(Lookup<TKey, TElement> lookup)
+        public SystemLinq_LookupDebugView(ILookup<TKey, TElement> lookup)
         {
             _lookup = lookup;
         }

src/libraries/System.Linq/src/System/Linq/DefaultIfEmpty.SpeedOpt.cs

@@ -13,7 +13,7 @@ private sealed partial class DefaultIfEmptyIterator<TSource> : IIListProvider<TS
             public TSource[] ToArray()
             {
                 TSource[] array = _source.ToArray();
-                return array.Length == 0 ? new[] { _default } : array;
+                return array.Length == 0 ? [_default] : array;
             }
 
             public List<TSource> ToList()