Fix double dispose in OrderBy, Shuffle, Shuffle.SkipTake

[apkd]

Hi, this is a followup to #192 - I came across the same problem in OrderBy, and it looks like Shuffle and Shuffle.SkipTake are also affected. I applied pretty much the same fix as before. I will test other operators when I have some time.

[apkd]

I also wrote some tests to reproduce the situation where double dispose matters. Let me know if you want them. These tests don't pass until the fixes are applied.

diff --git forkSrcPrefix/tests/ZLinq.Tests/Linq/OrderByTest.cs forkDstPrefix/tests/ZLinq.Tests/Linq/OrderByTest.cs
index b2d08bbd51fc6532d4956ee901124bdbdea0bbbc..977c37b64a8bc85d6e19b1881ba884c2b54575cd 100644
--- forkSrcPrefix/tests/ZLinq.Tests/Linq/OrderByTest.cs
+++ forkDstPrefix/tests/ZLinq.Tests/Linq/OrderByTest.cs
@@ -448,6 +448,13 @@ And Immortality.".Split([' ', '\n', '\r', '-'], StringSplitOptions.RemoveEmptyEn
         Assert.Equal(Enumerable.Range(0, 10).Reverse(), ordered);
     }
 
+    [Fact]
+    public void DoesNotDoubleDisposeTest()
+    {
+        // should not throw
+        new ValueEnumerableThatThrowsOnDoubleDispose().AsValueEnumerable().OrderBy(x => x).ToArray();
+    }
+
     private class ExtremeComparer : IComparer<int>
     {
         public int Compare(int x, int y)
diff --git forkSrcPrefix/tests/ZLinq.Tests/Linq/ReverseTest.cs forkDstPrefix/tests/ZLinq.Tests/Linq/ReverseTest.cs
index ac8e433fa6d07dfa8f1730724e02c855c66c75ab..9c7e0e8a56a380fd104b45af0bf7d8d2822b44dd 100644
--- forkSrcPrefix/tests/ZLinq.Tests/Linq/ReverseTest.cs
+++ forkDstPrefix/tests/ZLinq.Tests/Linq/ReverseTest.cs
@@ -218,6 +218,13 @@ public class ReverseTest
         // Dispose properly
         reversed.Dispose();
     }
+
+    [Fact]
+    public void DoesNotDoubleDisposeTest()
+    {
+        // should not throw
+        new ValueEnumerableThatThrowsOnDoubleDispose().AsValueEnumerable().Reverse().ToArray();
+    }
 }
 
 #if !NET10_0_OR_GREATER
diff --git forkSrcPrefix/tests/ZLinq.Tests/Linq/ShuffleSkipTest.cs forkDstPrefix/tests/ZLinq.Tests/Linq/ShuffleSkipTest.cs
index 3cdfd429c7916613ede61daff4219c5756413443..a8fa2d9be76597863fbc31d4aeaaa298501b8908 100644
--- forkSrcPrefix/tests/ZLinq.Tests/Linq/ShuffleSkipTest.cs
+++ forkDstPrefix/tests/ZLinq.Tests/Linq/ShuffleSkipTest.cs
@@ -209,4 +209,10 @@ public class ShuffleSkipTest
         source.Except(source.AsValueEnumerable().Shuffle().SkipLast(size).ToList()).Count().ShouldBe(size);
     }
 
+    [Fact]
+    public void DoesNotDoubleDisposeTest()
+    {
+        // should not throw
+        new ValueEnumerableThatThrowsOnDoubleDispose().AsValueEnumerable().Shuffle().Skip(1).ToArray();
+    }
 }
diff --git forkSrcPrefix/tests/ZLinq.Tests/Linq/ShuffleTest.cs forkDstPrefix/tests/ZLinq.Tests/Linq/ShuffleTest.cs
index 8b4ed368a97cbe5a460d60ba390f52f249482e28..c73ad84e58f271e134cfc0cb61a080ce01965893 100644
--- forkSrcPrefix/tests/ZLinq.Tests/Linq/ShuffleTest.cs
+++ forkDstPrefix/tests/ZLinq.Tests/Linq/ShuffleTest.cs
@@ -168,6 +168,13 @@ public class ShuffleTest
         collected.OrderBy(x => x).ShouldBe(original.OrderBy(x => x));
     }
 
+    [Fact]
+    public void DoesNotDoubleDisposeTest()
+    {
+        // should not throw
+        new ValueEnumerableThatThrowsOnDoubleDispose().AsValueEnumerable().Shuffle().ToArray();
+    }
+
     public struct TestStruct
     {
         public int Value;
diff --git forkSrcPrefix/tests/ZLinq.Tests/TestUtil.cs forkDstPrefix/tests/ZLinq.Tests/TestUtil.cs
index b4befda3a2e8487e92ebb854ddd8b975c5e0a66c..96af14bc00a6e0a65bd74fdf213e65a5fc59be5a 100644
--- forkSrcPrefix/tests/ZLinq.Tests/TestUtil.cs
+++ forkDstPrefix/tests/ZLinq.Tests/TestUtil.cs
@@ -228,3 +228,55 @@ public class DelegateBasedCollection<T> : ICollection<T>
     public IEnumerator<T> GetEnumerator() => GetEnumeratorWorker();
     IEnumerator IEnumerable.GetEnumerator() => NonGenericGetEnumeratorWorker();
 }
+
+public struct ValueEnumerableThatThrowsOnDoubleDispose
+    : IValueEnumerable<ValueEnumerableThatThrowsOnDoubleDispose, int>, IValueEnumerator<int>
+{
+    // This struct demonstrates a scenario where Dispose() affects external state, and
+    // it is forbidden to call it twice.
+    // A real-world equivalent would be ValueEnumerables based on Unity's ListPool<T>,
+    // which throws an exception when the list is returned to the pool more than once.
+
+    readonly bool[] disposeSentinel = new bool[1];
+    int index = -1;
+
+    public ValueEnumerableThatThrowsOnDoubleDispose() { }
+
+    public ValueEnumerable<ValueEnumerableThatThrowsOnDoubleDispose, int> AsValueEnumerable()
+        => new(this);
+
+    void IDisposable.Dispose()
+    {
+        if (disposeSentinel[0])
+            throw new ObjectDisposedException(nameof(ValueEnumerableThatThrowsOnDoubleDispose));
+
+        disposeSentinel[0] = true;
+    }
+
+    bool IValueEnumerator<int>.TryGetNext(out int current)
+    {
+        if (index++ < 10)
+        {
+            current = index;
+            return true;
+        }
+
+        current = 0;
+        return false;
+    }
+
+    bool IValueEnumerator<int>.TryGetNonEnumeratedCount(out int count)
+    {
+        count = 10;
+        return true;
+    }
+
+    bool IValueEnumerator<int>.TryGetSpan(out ReadOnlySpan<int> span)
+    {
+        span = default;
+        return false;
+    }
+
+    bool IValueEnumerator<int>.TryCopyTo(scoped Span<int> destination, Index offset)
+        => false;
+}

[neuecc]

Thank you, I'll merge and apply it just like before.