Don't extend collection types in ArrayOps

collections/src/main/scala/strawman/collection/concurrent/TrieMap.scala

@@ -582,19 +582,19 @@ private[collection] final class CNode[K, V](val bitmap: Int, val array: Array[Ba
   private[concurrent] def string(lev: Int): String = "CNode %x\n%s".format(bitmap, array.map(_.string(lev + 1)).mkString("\n"))
 
   /* quiescently consistent - don't call concurrently to anything involving a GCAS!! */
-  private def collectElems: Seq[(K, V)] = array flatMap {
+  private def collectElems: Seq[(K, V)] = array.flatMap({
     case sn: SNode[K, V] => Some(sn.kvPair): IterableOnce[(K, V)]
     case in: INode[K, V] => in.mainnode match {
       case tn: TNode[K, V] => Some(tn.kvPair): IterableOnce[(K, V)]
       case ln: LNode[K, V] => ln.entries.to(immutable.List)
       case cn: CNode[K, V] => cn.collectElems
     }
-  }
+  }: (BasicNode => IterableOnce[(K, V)])) //TODO remove type annotatation in 2.13
 
-  private def collectLocalElems: Seq[String] = array flatMap {
+  private def collectLocalElems: Seq[String] = array.flatMap({
     case sn: SNode[K, V] => Some(sn.kvPair._2.toString): IterableOnce[String]
     case in: INode[K, V] => Some(scala.Predef.augmentString(in.toString).drop(14) + "(" + in.gen + ")"): IterableOnce[String]
-  }
+  }: (BasicNode => IterableOnce[String])) //TODO remove type annotatation in 2.13
 
   override def toString = {
     val elems = collectLocalElems

collections/src/main/scala/strawman/collection/immutable/ImmutableArray.scala

@@ -1,7 +1,7 @@
 package strawman
 package collection.immutable
 
-import strawman.collection.mutable.{ArrayBuffer, Builder}
+import strawman.collection.mutable.{ArrayBuffer, Builder, ArrayBuilder}
 import strawman.collection.{IterableOnce, Iterator, SeqFactory, ClassTagSeqFactory, StrictOptimizedClassTagSeqFactory, View}
 
 import scala.{Any, ArrayIndexOutOfBoundsException, Boolean, Int, Nothing, UnsupportedOperationException, throws, Array, AnyRef, `inline`, Serializable, SerialVersionUID, Byte, Short, Long, Double, Unit, Float, Char}
@@ -66,27 +66,24 @@ sealed abstract class ImmutableArray[+A]
     ImmutableArray.unsafeWrapArray(dest)
   }
 
-  override def appendedAll[B >: A](xs: collection.Iterable[B]): ImmutableArray[B] =
-    xs match {
-      case bs: ImmutableArray[B] =>
-        val dest = Array.ofDim[Any](length + bs.length)
-        Array.copy(unsafeArray, 0, dest, 0, length)
-        Array.copy(bs.unsafeArray, 0, dest, length, bs.length)
-        ImmutableArray.unsafeWrapArray(dest)
-      case _ =>
-        fromIterable(new View.Concat(toIterable, xs))
-    }
+  override def appendedAll[B >: A](suffix: collection.Iterable[B]): ImmutableArray[B] = {
+    val b = ArrayBuilder.make[Any]()
+    val k = suffix.knownSize
+    if(k >= 0) b.sizeHint(k + unsafeArray.length)
+    b.addAll(unsafeArray)
+    b.addAll(suffix)
+    ImmutableArray.unsafeWrapArray(b.result())
+  }
 
-  override def prependedAll[B >: A](xs: collection.Iterable[B]): ImmutableArray[B] =
-    xs match {
-      case bs: ImmutableArray[B] =>
-        val dest = Array.ofDim[Any](length + bs.length)
-        Array.copy(bs.unsafeArray, 0, dest, 0, bs.length)
-        Array.copy(unsafeArray, 0, dest, bs.length, length)
-        ImmutableArray.unsafeWrapArray(dest)
-      case _ =>
-        fromIterable(new View.Concat(xs, toIterable))
-    }
+  override def prependedAll[B >: A](prefix: collection.Iterable[B]): ImmutableArray[B] = {
+    val b = ArrayBuilder.make[Any]()
+    val k = prefix.knownSize
+    if(k >= 0) b.sizeHint(k + unsafeArray.length)
+    b.addAll(prefix)
+    if(k < 0) b.sizeHint(b.length + unsafeArray.length)
+    b.addAll(unsafeArray)
+    ImmutableArray.unsafeWrapArray(b.result())
+  }
 
   override def zip[B](that: collection.Iterable[B]): ImmutableArray[(A, B)] =
     that match {
@@ -122,6 +119,14 @@ sealed abstract class ImmutableArray[+A]
   override def reverse: ImmutableArray[A] = iterableFactory.tabulate(length)(i => apply(length - 1 - i))
 
   override def className = "ImmutableArray"
+
+  override def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type = copyToArray[B](xs, start, length)
+
+  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): xs.type = {
+    val l = scala.math.min(scala.math.min(len, length), xs.length-start)
+    if(l > 0) Array.copy(unsafeArray, 0, xs, start, l)
+    xs
+  }
 }
 
 /**

collections/src/main/scala/strawman/collection/immutable/TrieIterator.scala

@@ -74,7 +74,7 @@ private[collection] abstract class TrieIterator[+T](elems: Array[Iterable[T]]) e
   }
 
   private[this] def iteratorWithSize(arr: Array[Iterable[T]]): (Iterator[T], Int) =
-    (newIterator(arr), ((arr.map(_.size): Array[Int]): strawman.collection.IterableOps[Int, Iterable, _]).sum)
+    (newIterator(arr), ((arr.map(_.size): Array[Int]): strawman.collection.IterableOps[Int, strawman.collection.Iterable, _]).sum)
 
   private[this] def arrayToIterators(arr: Array[Iterable[T]]): SplitIterators = {
     val (fst, snd) = arr.splitAt(arr.length / 2)

collections/src/main/scala/strawman/collection/mutable/ArrayBuffer.scala

@@ -163,6 +163,13 @@ class ArrayBuffer[A] private (initElems: Array[AnyRef], initSize: Int)
 
   override def className = "ArrayBuffer"
 
+  override def copyToArray[B >: A](xs: Array[B], start: Int = 0): xs.type = copyToArray[B](xs, start, length)
+
+  override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): xs.type = {
+    val l = scala.math.min(scala.math.min(len, length), xs.length-start)
+    if(l > 0) Array.copy(array, 0, xs, start, l)
+    xs
+  }
 }
 
 /**