Optimise factories for Array-based collections

Optimise `from` methods on factories for `Array`-based collections by having them call `copyToArray` on the source collection. Deprecate overriding the overloads of `copyToArray` with fewer args, and remove overrides of those methods from the standard library. Fix incorrect doc about termination of `copyToArray` for infinite collections. Add helper method similar to `Array.from` for calling `copyToArray` on an `IterableOnce`.

Author: NthPortal

library/src/scala/collection/IterableOnce.scala

@@ -265,6 +265,16 @@ object IterableOnce {
  */
  @inline private[collection] def elemsToCopyToArray(srcLen: Int, destLen: Int, start: Int, len: Int): Int =
  math.max(math.min(math.min(len, srcLen), destLen - start), 0)
+
+ /** Calls `copyToArray` on the given collection, regardless of whether or not it is an `Iterable`. */
+ @inline private[collection] def copyElemsToArray[A, B >: A](elems: IterableOnce[A],
+ xs: Array[B],
+ start: Int = 0,
+ len: Int = Int.MaxValue): Int =
+ elems match {
+ case src: Iterable[A] => src.copyToArray[B](xs, start, len)
+ case src => src.iterator.copyToArray[B](xs, start, len)
+ }
 }
 
 /** This implementation trait can be mixed into an `IterableOnce` to get the basic methods that are shared between
@@ -819,9 +829,10 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
  * @tparam B the type of the elements of the array.
  * @return the number of elements written to the array
  *
- * $willNotTerminateInf
+ * @note Reuse: $consumesIterator
  */
- def copyToArray[B >: A](xs: Array[B]): Int = copyToArray(xs, 0)
+ @deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")
+ def copyToArray[B >: A](xs: Array[B]): Int = copyToArray(xs, 0, Int.MaxValue)
 
  /** Copy elements to an array, returning the number of elements written.
  *
@@ -835,18 +846,10 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
  * @tparam B the type of the elements of the array.
  * @return the number of elements written to the array
  *
- * $willNotTerminateInf
+ * @note Reuse: $consumesIterator
  */
- def copyToArray[B >: A](xs: Array[B], start: Int): Int = {
- val xsLen = xs.length
- val it = iterator
- var i = start
- while (i < xsLen && it.hasNext) {
- xs(i) = it.next()
- i += 1
- }
- i - start
- }
+ @deprecatedOverriding("This should always forward to the 3-arg version of this method", since = "2.13.4")
+ def copyToArray[B >: A](xs: Array[B], start: Int): Int = copyToArray(xs, start, Int.MaxValue)
 
  /** Copy elements to an array, returning the number of elements written.
  *
@@ -862,8 +865,6 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
  * @return the number of elements written to the array
  *
  * @note Reuse: $consumesIterator
- *
- * $willNotTerminateInf
  */
  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = {
  val it = iterator

library/src/scala/collection/immutable/ArraySeq.scala

@@ -237,8 +237,6 @@ sealed abstract class ArraySeq[+A]
 
  override protected[this] def className = "ArraySeq"
 
- override def copyToArray[B >: A](xs: Array[B], start: Int = 0): Int = copyToArray[B](xs, start, length)
-
  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = {
  val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
  if(copied > 0) {

library/src/scala/collection/immutable/WrappedString.scala

@@ -88,9 +88,6 @@ final class WrappedString(private val self: String) extends AbstractSeq[Char] wi
  case _ => super.lastIndexOf(elem, end)
  }
 
- override def copyToArray[B >: Char](xs: Array[B], start: Int): Int =
- copyToArray(xs, start, length)
-
  override def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Int =
  (xs: Any) match {
  case chs: Array[Char] =>

library/src/scala/collection/mutable/ArrayBuffer.scala

@@ -219,8 +219,6 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
 
  override protected[this] def stringPrefix = "ArrayBuffer"
 
- override def copyToArray[B >: A](xs: Array[B], start: Int): Int = copyToArray[B](xs, start, length)
-
  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = {
  val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
  if(copied > 0) {
@@ -258,8 +256,7 @@ object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer] {
  val k = coll.knownSize
  if (k >= 0) {
  val array = new Array[AnyRef](k max DefaultInitialSize)
- val it = coll.iterator
- for (i <- 0 until k) array(i) = it.next().asInstanceOf[AnyRef]
+ IterableOnce.copyElemsToArray(coll, array.asInstanceOf[Array[Any]])
  new ArrayBuffer[B](array, k)
  }
  else new ArrayBuffer[B] ++= coll

library/src/scala/collection/mutable/ArrayBuilder.scala

@@ -59,14 +59,11 @@ sealed abstract class ArrayBuilder[T]
 
  override def addAll(xs: IterableOnce[T]): this.type = {
  val k = xs.knownSize
- if(k > 0) {
+ if (k > 0) {
  ensureSize(this.size + k)
- xs match {
- case xs: Iterable[T] => xs.copyToArray(elems, this.size)
- case _ => xs.iterator.copyToArray(elems, this.size)
- }
+ IterableOnce.copyElemsToArray(xs, elems, this.size)
  size += k
- } else if(k < 0) super.addAll(xs)
+ } else if (k < 0) super.addAll(xs)
  this
  }
 }

library/src/scala/collection/mutable/ArrayDeque.scala

@@ -527,14 +527,9 @@ object ArrayDeque extends StrictOptimizedSeqFactory[ArrayDeque] {
  val s = coll.knownSize
  if (s >= 0) {
  val array = alloc(s)
- val it = coll.iterator
- var i = 0
- while (it.hasNext) {
- array(i) = it.next().asInstanceOf[AnyRef]
- i += 1
- }
+ IterableOnce.copyElemsToArray(coll, array.asInstanceOf[Array[Any]])
  new ArrayDeque[B](array, start = 0, end = s)
- } else empty[B] ++= coll
+ } else new ArrayDeque[B]() ++= coll
  }
 
  def newBuilder[A]: Builder[A, ArrayDeque[A]] =

library/src/scala/collection/mutable/ArraySeq.scala

@@ -18,7 +18,6 @@ import java.util.Arrays
 import scala.collection.Stepper.EfficientSplit
 import scala.collection.convert.impl._
 import scala.reflect.ClassTag
-import scala.runtime.ScalaRunTime
 import scala.util.hashing.MurmurHash3
 
 /**
@@ -74,8 +73,6 @@ sealed abstract class ArraySeq[T]
  /** Clones this object, including the underlying Array. */
  override def clone(): ArraySeq[T] = ArraySeq.make(array.clone()).asInstanceOf[ArraySeq[T]]
 
- override def copyToArray[B >: T](xs: Array[B], start: Int): Int = copyToArray[B](xs, start, length)
-
  override def copyToArray[B >: T](xs: Array[B], start: Int, len: Int): Int = {
  val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
  if(copied > 0) {
@@ -110,19 +107,7 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
  private[this] val EmptyArraySeq = new ofRef[AnyRef](new Array[AnyRef](0))
  def empty[T : ClassTag]: ArraySeq[T] = EmptyArraySeq.asInstanceOf[ArraySeq[T]]
 
- def from[A : ClassTag](it: scala.collection.IterableOnce[A]): ArraySeq[A] = {
- val n = it.knownSize
- if (n > -1) {
- val elements = scala.Array.ofDim[A](n)
- val iterator = it.iterator
- var i = 0
- while (i < n) {
- ScalaRunTime.array_update(elements, i, iterator.next())
- i = i + 1
- }
- make(elements)
- } else make(ArrayBuffer.from(it).toArray)
- }
+ def from[A : ClassTag](it: scala.collection.IterableOnce[A]): ArraySeq[A] = make(Array.from[A](it))
 
  def newBuilder[A : ClassTag]: Builder[A, ArraySeq[A]] = ArrayBuilder.make[A].mapResult(make)
 

library/src/scala/collection/mutable/PriorityQueue.scala

@@ -348,8 +348,6 @@ sealed class PriorityQueue[A](implicit val ord: Ordering[A])
  pq
  }
 
- override def copyToArray[B >: A](xs: Array[B], start: Int): Int = copyToArray(xs, start, length)
-
  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int = {
  val copied = IterableOnce.elemsToCopyToArray(length, xs.length, start, len)
  if (copied > 0) {