Merge pull request #112 from xuwei-k/fix-mutable-ArraySeq

fix compile errors in latest Scala 2.13

Author: lrytz

src/main/scala/scala/compat/java8/StreamConverters.scala

@@ -5,6 +5,7 @@ import scala.language.higherKinds
 import java.util.stream._
 import scala.compat.java8.collectionImpl._
 import scala.compat.java8.converterImpl._
+import scala.reflect.ClassTag
 
 /** Classes or objects implementing this trait create streams suitable for sequential use */
 trait MakesSequentialStream[T, SS <: java.util.stream.BaseStream[_, SS]] extends Any {
@@ -177,6 +178,13 @@ extends Priority1StreamConverters
 with converterImpl.Priority1StepConverters
 with converterImpl.Priority1AccumulatorConverters
 {
+  private[java8] def unsafeArrayIfPossible[A](a: collection.mutable.ArraySeq[A])(implicit c: ClassTag[A]): Array[A] = {
+    if (a.elemTag == c)
+      a.array.asInstanceOf[Array[A]]
+    else
+      a.toArray
+  }
+
   implicit final class EnrichDoubleArrayWithStream(private val a: Array[Double])
   extends AnyVal with MakesSequentialStream[Double, DoubleStream] with MakesParallelStream[Double, DoubleStream] {
     def seqStream: DoubleStream = java.util.Arrays.stream(a)
@@ -197,19 +205,19 @@ with converterImpl.Priority1AccumulatorConverters
 
   implicit final class EnrichDoubleArraySeqWithStream(private val a: collection.mutable.ArraySeq[Double])
     extends AnyVal with MakesSequentialStream[Double, DoubleStream] with MakesParallelStream[Double, DoubleStream] {
-    def seqStream: DoubleStream = java.util.Arrays.stream(a.array)
+    def seqStream: DoubleStream = java.util.Arrays.stream(unsafeArrayIfPossible(a))
     def parStream: DoubleStream = seqStream.parallel
   }
 
   implicit final class EnrichIntArraySeqWithStream(private val a: collection.mutable.ArraySeq[Int])
     extends AnyVal with MakesSequentialStream[Int, IntStream] with MakesParallelStream[Int, IntStream] {
-    def seqStream: IntStream = java.util.Arrays.stream(a.array)
+    def seqStream: IntStream = java.util.Arrays.stream(unsafeArrayIfPossible(a))
     def parStream: IntStream = seqStream.parallel
   }
 
   implicit final class EnrichLongArraySeqWithStream(private val a: collection.mutable.ArraySeq[Long])
     extends AnyVal with MakesSequentialStream[Long, LongStream] with MakesParallelStream[Long, LongStream] {
-    def seqStream: LongStream = java.util.Arrays.stream(a.array)
+    def seqStream: LongStream = java.util.Arrays.stream(unsafeArrayIfPossible(a))
     def parStream: LongStream = seqStream.parallel
   }
 

src/main/scala/scala/compat/java8/converterImpl/StepConverters.scala

@@ -1,6 +1,8 @@
-package scala.compat.java8.converterImpl
+package scala.compat.java8
+package converterImpl
 
 import language.implicitConversions
+import scala.reflect.ClassTag
 
 trait Priority3StepConverters {
   implicit def richIterableCanStep[A](underlying: Iterable[A]) = new RichIterableCanStep(underlying)
@@ -16,7 +18,7 @@ trait Priority1StepConverters extends Priority2StepConverters {
   implicit def richDefaultHashMapCanStep[K, V](underlying: collection.mutable.HashMap[K, V]) = new RichHashMapCanStep[K, V](underlying)
   implicit def richLinkedHashMapCanStep[K, V](underlying: collection.mutable.LinkedHashMap[K, V]) = new RichLinkedHashMapCanStep[K, V](underlying)
   implicit def richArrayCanStep[A](underlying: Array[A]) = new RichArrayCanStep[A](underlying)
-  implicit def richArraySeqCanStep[A](underlying: collection.mutable.ArraySeq[A]) = new RichArrayCanStep[A](underlying.array)
+  implicit def richArraySeqCanStep[A: ClassTag](underlying: collection.mutable.ArraySeq[A]) = new RichArrayCanStep[A](StreamConverters.unsafeArrayIfPossible(underlying))
   implicit def richHashSetCanStep[A](underlying: collection.mutable.HashSet[A]) = new RichHashSetCanStep[A](underlying)
   implicit def richIteratorCanStep[A](underlying: Iterator[A]) = new RichIteratorCanStep(underlying)
   implicit def richImmHashMapCanStep[K, V](underlying: collection.immutable.HashMap[K, V]) = new RichImmHashMapCanStep[K, V](underlying)