prepare for Dotty: avoid unchecked warnings

Author: SethTisue

core/src/main/scala/scala/collection/immutable/OldHashMap.scala

@@ -117,7 +117,7 @@ object OldHashMap extends MapFactory[OldHashMap] {
 
   def from[K, V](it: collection.IterableOnce[(K, V)]): OldHashMap[K, V] =
     it match {
-      case hm: OldHashMap[K, V] => hm
+      case hm: OldHashMap[K @unchecked, V @unchecked] => hm
       case _ => (newBuilder[K, V] ++= it).result()
     }
 

core/src/main/scala/scala/collection/immutable/OldHashSet.scala

@@ -61,7 +61,7 @@ sealed abstract class OldHashSet[A]
   }
 
   override def concat(that: collection.IterableOnce[A]): OldHashSet[A] = that match {
-    case that: OldHashSet[A] =>
+    case that: OldHashSet[A @unchecked] =>
       val buffer = new Array[OldHashSet[A]](bufferSize(this.size + that.size))
       nullToEmpty(union0(that, 0, buffer, 0))
     case _ => super.concat(that)
@@ -167,7 +167,7 @@ object OldHashSet extends IterableFactory[OldHashSet] {
 
   def from[A](it: collection.IterableOnce[A]): OldHashSet[A] =
     it match {
-      case hs: OldHashSet[A] => hs
+      case hs: OldHashSet[A @unchecked] => hs
       case _ => (newBuilder[A] ++= it).result()
     }
 

core/src/main/scala/scala/collection/parallel/CollectionConverters.scala

@@ -26,10 +26,10 @@ object CollectionConverters {
   implicit class IterableIsParallelizable[A](private val coll: sc.Iterable[A]) extends AnyVal with sc.CustomParallelizable[A, ParIterable[A]] {
     def seq = coll
     override def par = coll match {
-      case coll: sc.Set[A] => new SetIsParallelizable(coll).par
+      case coll: sc.Set[A @unchecked] => new SetIsParallelizable(coll).par
       case coll: sc.Map[_, _] => new MapIsParallelizable(coll).par.asInstanceOf[ParIterable[A]]
       case coll: sci.Iterable[A] => new ImmutableIterableIsParallelizable(coll).par
-      case coll: scm.Iterable[A] => new MutableIterableIsParallelizable(coll).par
+      case coll: scm.Iterable[A @unchecked] => new MutableIterableIsParallelizable(coll).par
       case _ => ParIterable.newCombiner[A].fromSequential(seq) // builds ParArray, same as for scm.Iterable
     }
   }
@@ -48,15 +48,15 @@ object CollectionConverters {
     def seq = coll
     override def par = coll match {
       case coll: sci.Seq[A] => new ImmutableSeqIsParallelizable(coll).par
-      case coll: sci.Set[A] => new ImmutableSetIsParallelizable(coll).par
+      case coll: sci.Set[A @unchecked] => new ImmutableSetIsParallelizable(coll).par
       case coll: sci.Map[_, _] => new ImmutableMapIsParallelizable(coll).par.asInstanceOf[immutable.ParIterable[A]]
       case _ => immutable.ParIterable.newCombiner[A].fromSequential(seq) // builds ParVector
     }
   }
 
   // Seq
   implicit def seqIsParallelizable[A](coll: sc.Seq[A]): sc.Parallelizable[A, ParSeq[A]] = coll match {
-    case it: scm.Seq[A] => new MutableSeqIsParallelizable(it)
+    case it: scm.Seq[A @unchecked] => new MutableSeqIsParallelizable(it)
     case it: sci.Seq[A] => new ImmutableSeqIsParallelizable(it)
     case _ => throw new IllegalArgumentException("Unexpected type "+coll.getClass.getName+" - every scala.collection.Seq must be a scala.collection.mutable.Seq or scala.collection.immutable.Seq")
   }
@@ -144,7 +144,7 @@ object CollectionConverters {
     def seq = coll
     override def par = coll match {
       case coll: sci.Map[K, V] => new ImmutableMapIsParallelizable(coll).par
-      case coll: scm.Map[K, V] => new MutableMapIsParallelizable(coll).par
+      case coll: scm.Map[K @unchecked, V @unchecked] => new MutableMapIsParallelizable(coll).par
       case _ => ParMap.newCombiner[K, V].fromSequential(seq)
     }
   }

core/src/main/scala/scala/collection/parallel/immutable/ParHashMap.scala

@@ -94,7 +94,7 @@ self =>
     def split: Seq[IterableSplitter[(K, V)]] = if (remaining < 2) Seq(this) else triter match {
       case t: TrieIterator[_] =>
         val previousRemaining = remaining
-        val ((fst, fstlength), snd) = t.split
+        val ((fst: Iterator[(K, V) @unchecked], fstlength), snd: Iterator[(K, V) @unchecked]) = t.split
         val sndlength = previousRemaining - fstlength
         Seq(
           new ParHashMapIterator(fst, fstlength),

core/src/main/scala/scala/collection/parallel/mutable/ParTrieMap.scala

@@ -104,7 +104,7 @@ extends ParMap[K, V]
       while (i < until) {
         array(i) match {
           case sn: SNode[_, _] => sz += 1
-          case in: INode[K, V] => sz += in.cachedSize(ctrie)
+          case in: INode[K @unchecked, V @unchecked] => sz += in.cachedSize(ctrie)
         }
         i += 1
       }