Fix LargeArrayBuilder.CopyTo returning incorrect end-of-copy position

src/Common/src/System/Collections/Generic/LargeArrayBuilder.cs

@@ -198,7 +198,7 @@ public void CopyTo(T[] array, int arrayIndex, int count)
  public CopyPosition CopyTo(CopyPosition position, T[] array, int arrayIndex, int count)
  {
  Debug.Assert(arrayIndex >= 0);
- Debug.Assert(count >= 0 && count <= Count);
+ Debug.Assert(count > 0 && count <= Count);
  Debug.Assert(array?.Length - arrayIndex >= count);
 
  // Go through each buffer, which contains one 'row' of items.
@@ -216,25 +216,36 @@ public CopyPosition CopyTo(CopyPosition position, T[] array, int arrayIndex, int
  int row = position.Row;
  int column = position.Column;
 
- for (; count > 0; row++, column = 0)
+ T[] buffer = GetBuffer(row);
+ int copied = CopyToCore(buffer, column);
+
+ while (count > 0)
+ {
+ buffer = GetBuffer(++row);
+ copied = CopyToCore(buffer, 0);
+ }
+
+ return copied == buffer.Length
+ ? new CopyPosition(row + 1, 0)
+ : new CopyPosition(row, copied);
+
+ int CopyToCore(T[] sourceBuffer, int sourceIndex)
  {
- T[] buffer = GetBuffer(index: row);
+ Debug.Assert(sourceBuffer.Length > sourceIndex);
 
- // During this iteration, copy until we satisfy `count` or reach the
- // end of the current buffer.
- int copyCount = Math.Min(buffer.Length, count);
+ // Copy until we satisfy `count` or reach the end of the current buffer.
+ int copyCount = Math.Min(sourceBuffer.Length - sourceIndex, count);
 
  if (copyCount > 0)
  {
- Array.Copy(buffer, column, array, arrayIndex, copyCount);
+ Array.Copy(sourceBuffer, sourceIndex, array, arrayIndex, copyCount);
 
  arrayIndex += copyCount;
  count -= copyCount;
- column += copyCount;
  }
- }
 
- return new CopyPosition(row: row, column: column);
+ return copyCount;
+ }
  }
 
  /// <summary>

src/Common/src/System/Collections/Generic/SparseArrayBuilder.cs

@@ -149,8 +149,11 @@ public void CopyTo(T[] array, int arrayIndex, int count)
  count -= reservedCount;
  }
 
- // Finish copying after the final marker.
- _builder.CopyTo(position, array, arrayIndex, count);
+ if (count > 0)
+ {
+ // Finish copying after the final marker.
+ _builder.CopyTo(position, array, arrayIndex, count);
+ }
  }
 
  /// <summary>

src/System.Linq/tests/ConcatTests.cs

@@ -421,5 +421,18 @@ public void GetEnumerableOfConcatCollectionChainFollowedByEnumerableNodeShouldBe
  Assert.Equal(0xf00, en.Current);
  }
  }
+
+ [Fact]
+ public void CollectionInterleavedWithLazyEnumerables_ToArray_Regression()
+ {
+ var results = new TestEnumerable<int>(new[] { 1 })
+ .Concat(new[] { 2 })
+ .Concat(new TestEnumerable<int>(new[] { 3 }))
+ // Do not omit this ToArray()! There was a previous bug where the ToArray() implementation
+ // was incorrect, while iterating with foreach produced the correct results.
+ .ToArray();
+
+ Assert.Equal(new[] { 1, 2, 3 }, results);
+ }
  }
 }

src/System.Linq/tests/SelectManyTests.cs

@@ -477,5 +477,19 @@ public void ThrowOverflowExceptionOnConstituentLargeCounts(int[] counts)
  IEnumerable<int> iterator = counts.SelectMany(c => Enumerable.Range(1, c));
  Assert.Throws<OverflowException>(() => iterator.Count());
  }
+
+ [Fact]
+ public void CollectionInterleavedWithLazyEnumerables_ToArray_Regression()
+ {
+ var results = new[] { 4, 5, 6 }
+ .SelectMany(i => i == 5 ?
+ (IEnumerable<int>)new List<int>() { i } :
+ new TestEnumerable<int>(new int[] { i }))
+ // Do not omit this ToArray()! There was a previous bug where the ToArray() implementation
+ // was incorrect, while iterating with foreach produced the correct results.
+ .ToArray();
+
+ Assert.Equal(new[] { 4, 5, 6 }, results);
+ }
  }
 }