Combine Linq optimisations [WIP]

src/System.Linq/tests/DistinctTests.cs

@@ -198,5 +198,33 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<int>;
             Assert.False(en != null && en.MoveNext());
         }
+
+        [Fact]
+        public void ToArray()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+            int?[] expected = { 1, 2, null };
+
+            Assert.Equal(expected, source.Distinct().ToArray());
+        }
+
+        [Fact]
+        public void ToList()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+            int?[] expected = { 1, 2, null };
+
+            Assert.Equal(expected, source.Distinct().ToList());
+        }
+
+        [Fact]
+        public void RepeatEnumerating()
+        {
+            int?[] source = { 1, 1, 1, 2, 2, 2, null, null };
+
+            var result = source.Distinct();
+
+            Assert.Equal(result, result);
+        }
     }
 }

src/System.Linq/tests/ElementAtOrDefaultTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -131,5 +132,35 @@ public void NullSource()
         {
             Assert.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).ElementAtOrDefault(2));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAtOrDefault(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Equal(0, source.ElementAtOrDefault(-1));
+            Assert.Equal(0, source.ElementAtOrDefault(4));
+        }
     }
 }

src/System.Linq/tests/ElementAtTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -131,5 +132,35 @@ public void NullSource()
         {
             Assert.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).ElementAt(2));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            var source = new[] { 1, 2, 3, 4 }.ToList().Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            var source = new ReadOnlyCollection<int>(new[] { 1, 2, 3, 4 }).Select(i => i * 2);
+            for (int i = 0; i != 4; ++i)
+                Assert.Equal((i + 1) * 2, source.ElementAt(i));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(-1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => source.ElementAt(4));
+        }
     }
 }

src/System.Linq/tests/FirstOrDefaultTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -194,5 +195,26 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).FirstOrDefault(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new int[0].Select(i => i * 2 + 1).FirstOrDefault());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new List<int>(0).Select(i => i * 2 + 1).FirstOrDefault());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(11, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).FirstOrDefault());
+            Assert.Equal(0, new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1).FirstOrDefault());
+        }
     }
 }

src/System.Linq/tests/FirstTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -191,5 +192,29 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).First(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).First());
+            var emptySource = new int[0].Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(11, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).First());
+            var emptySource = new List<int>(0).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(11, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).First());
+            var emptySource = new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.First());
+        }
     }
 }

src/System.Linq/tests/GroupByTests.cs

@@ -630,5 +630,17 @@ public void GroupingWithResultsToList()
             Assert.Equal(4, groupedList.Count);
             Assert.Equal(source.GroupBy(r => r.Name, (r, e) => e), groupedList);
         }
+
+        [Fact]
+        public void EmptyGroupingToArray()
+        {
+            Assert.Empty(Enumerable.Empty<int>().GroupBy(i => i).ToArray());
+        }
+
+        [Fact]
+        public void EmptyGroupingToList()
+        {
+            Assert.Empty(Enumerable.Empty<int>().GroupBy(i => i).ToList());
+        }
     }
 }

src/System.Linq/tests/LastOrDefaultTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests.LegacyTests
@@ -244,5 +245,26 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).LastOrDefault(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new int[0].Select(i => i * 2 + 1).LastOrDefault());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new List<int>(0).Select(i => i * 2 + 1).LastOrDefault());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(17, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).LastOrDefault());
+            Assert.Equal(0, new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1).LastOrDefault());
+        }
     }
 }

src/System.Linq/tests/LastTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Linq.Tests
@@ -239,5 +240,29 @@ public void NullPredicate()
             Func<int, bool> predicate = null;
             Assert.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).Last(predicate));
         }
+
+        [Fact]
+        public void ArraySelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.Select(i => i * 2 + 1).Last());
+            var emptySource = new int[0].Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
+
+        [Fact]
+        public void ListSelectSource()
+        {
+            Assert.Equal(17, new[] { 5, 6, 7, 8 }.ToList().Select(i => i * 2 + 1).Last());
+            var emptySource = new List<int>(0).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
+
+        [Fact]
+        public void IListSelectSource()
+        {
+            Assert.Equal(17, new ReadOnlyCollection<int>(new[] { 5, 6, 7, 8 }).Select(i => i * 2 + 1).Last());
+            var emptySource = new ReadOnlyCollection<int>(new int[0]).Select(i => i * 2 + 1);
+            Assert.Throws<InvalidOperationException>(() => emptySource.Last());
+        }
     }
 }

src/System.Linq/tests/OrderedSubsetting.cs

@@ -302,30 +302,84 @@ public void ToArray()
             Assert.Equal(Enumerable.Range(10, 20), Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(10).Take(20).ToArray());
         }
 
+        [Fact]
+        public void ToList()
+        {
+            Assert.Equal(Enumerable.Range(10, 20), Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(10).Take(20).ToList());
+        }
+
         [Fact]
         public void EmptyToArray()
         {
             Assert.Empty(Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(100).ToArray());
         }
 
+        [Fact]
+        public void EmptyToList()
+        {
+            Assert.Empty(Enumerable.Range(0, 100).Shuffle().OrderBy(i => i).Skip(100).ToList());
+        }
+
         [Fact]
         public void AttemptedMoreArray()
         {
             Assert.Equal(Enumerable.Range(0, 20), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Take(30).ToArray());
         }
 
+        [Fact]
+        public void AttemptedMoreToList()
+        {
+            Assert.Equal(Enumerable.Range(0, 20), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Take(30).ToList());
+        }
+
         [Fact]
         public void SingleElementToArray()
         {
             Assert.Equal(Enumerable.Repeat(10, 1), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Skip(10).Take(1).ToArray());
         }
 
+        [Fact]
+        public void SingleElementToList()
+        {
+            Assert.Equal(Enumerable.Repeat(10, 1), Enumerable.Range(0, 20).Shuffle().OrderBy(i => i).Skip(10).Take(1).ToList());
+        }
+
         [Fact]
         public void EnumeratorDoesntContinue()
         {
             var enumerator = NumberRangeGuaranteedNotCollectionType(0, 3).Shuffle().OrderBy(i => i).Skip(1).GetEnumerator();
             while (enumerator.MoveNext()) { }
             Assert.False(enumerator.MoveNext());
         }
+
+        [Fact]
+        public void SubsetAfterSelect()
+        {
+            var page = Enumerable.Range(0, 50).Shuffle().OrderBy(i => i).Select(i => i * 2).Skip(20).Take(5);
+            Assert.Equal(new[] { 40, 42, 44, 46, 48 }, page);
+            Assert.Equal(new[] { 41, 43, 45, 47, 49 }, page.Select(i => i + 1));
+            Assert.Equal(40, page.First());
+            Assert.Equal(48, page.Last());
+            Assert.Equal(42, page.ElementAt(1));
+            Assert.Throws<ArgumentOutOfRangeException>("index", () => page.ElementAt(20));
+            page = Enumerable.Range(0, 50).Shuffle().OrderBy(i => i).Select(i => i * 2).Skip(100).Take(5);
+            Assert.Throws<InvalidOperationException>(() => page.First());
+            Assert.Throws<InvalidOperationException>(() => page.Last());
+        }
+
+        [Fact]
+        public void SubsetAfterSelectEnumeratorDoesntContinue()
+        {
+            var enumerator = NumberRangeGuaranteedNotCollectionType(0, 3).Shuffle().OrderBy(i => i).Select(i => i * 2).Take(1).GetEnumerator();
+            while (enumerator.MoveNext()) { }
+            Assert.False(enumerator.MoveNext());
+        }
+
+        [Fact]
+        public void SubsetAfterSelectRepeatEnumerating()
+        {
+            var page = NumberRangeGuaranteedNotCollectionType(0, 3).Shuffle().OrderBy(i => i).Select(i => i * 2).Take(1);
+            Assert.Equal(page, page);
+        }
     }
 }