prepare for Dotty: add @uncheckedVariance as needed to satisfy compiler

Author: SethTisue

core/src/main/scala/scala/collection/CustomParallelizable.scala

@@ -13,10 +13,8 @@
 package scala
 package collection
 
-import parallel.Combiner
-
 trait CustomParallelizable[+A, +ParRepr <: Parallel] extends Any with Parallelizable[A, ParRepr] {
   override def par: ParRepr
-  override protected[this] def parCombiner: Combiner[A, ParRepr] = throw new UnsupportedOperationException("")
+  override protected[this] def parCombiner = throw new UnsupportedOperationException("")
 }
 

core/src/main/scala/scala/collection/Parallelizable.scala

@@ -14,6 +14,7 @@ package scala
 package collection
 
 import parallel.Combiner
+import scala.annotation.unchecked.uncheckedVariance
 
 /** This trait describes collections which can be turned into parallel collections
  *  by invoking the method `par`. Parallelizable collections may be parameterized with
@@ -48,6 +49,6 @@ trait Parallelizable[+A, +ParRepr <: Parallel] extends Any {
    *
    *  @return  a combiner for the parallel collection of type `ParRepr`
    */
-  protected[this] def parCombiner: Combiner[A, ParRepr]
+  protected[this] def parCombiner: Combiner[A @uncheckedVariance, ParRepr]
 }
 

core/src/main/scala/scala/collection/generic/GenericParTemplate.scala

@@ -31,12 +31,9 @@ trait GenericParTemplate[+A, +CC[X] <: ParIterable[X]]
 {
   def companion: GenericParCompanion[CC]
 
-  protected[this] override def newBuilder: scala.collection.mutable.Builder[A, CC[A]] = newCombiner
+  protected[this] override def newBuilder = newCombiner
 
-  protected[this] override def newCombiner: Combiner[A, CC[A]] = {
-    val cb = companion.newCombiner[A]
-    cb
-  }
+  protected[this] override def newCombiner = companion.newCombiner[A]
 
   override def genericBuilder[B]: Combiner[B, CC[B]] = genericCombiner[B]
 
@@ -50,7 +47,7 @@ trait GenericParTemplate[+A, +CC[X] <: ParIterable[X]]
 
 trait GenericParMapTemplate[K, +V, +CC[X, Y] <: ParMap[X, Y]] extends GenericParTemplate[(K, V), ParIterable]
 {
-  protected[this] override def newCombiner: Combiner[(K, V), CC[K, V]] = {
+  protected[this] override def newCombiner: Combiner[(K, V @uncheckedVariance), CC[K, V @uncheckedVariance]] = {
     val cb = mapCompanion.newCombiner[K, V]
     cb
   }

core/src/main/scala/scala/collection/generic/GenericTraversableTemplate.scala

@@ -63,7 +63,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: ParIterable[X]] extends HasNewBui
 
   /** The builder that builds instances of type $Coll[A]
    */
-  protected[this] def newBuilder: Builder[A, CC[A]] = companion.newBuilder[A]
+  protected[this] def newBuilder: Builder[A @uncheckedVariance, CC[A @uncheckedVariance]] = companion.newBuilder[A]
 
   /** The generic builder that builds instances of $Coll
    *  at arbitrary element types.

core/src/main/scala/scala/collection/generic/HasNewBuilder.scala

@@ -15,8 +15,9 @@ package collection
 package generic
 
 import mutable.Builder
+import scala.annotation.unchecked.uncheckedVariance
 
 trait HasNewBuilder[+A, +Repr] extends Any {
   /** The builder that builds instances of Repr */
-  protected[this] def newBuilder: Builder[A, Repr]
+  protected[this] def newBuilder: Builder[A @uncheckedVariance, Repr]
 }

core/src/main/scala/scala/collection/generic/HasNewCombiner.scala

@@ -15,8 +15,9 @@ package collection
 package generic
 
 import scala.collection.parallel.Combiner
+import scala.annotation.unchecked.uncheckedVariance
 
 trait HasNewCombiner[+T, +Repr] {
-  protected[this] def newCombiner: Combiner[T, Repr]
+  protected[this] def newCombiner: Combiner[T @uncheckedVariance, Repr]
 }
 

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

@@ -18,6 +18,7 @@ import scala.collection.generic.DefaultSignalling
 import scala.collection.generic.AtomicIndexFlag
 import scala.collection.generic.VolatileAbort
 import scala.collection.parallel.ParallelCollectionImplicits._
+import scala.annotation.unchecked.uncheckedVariance
 
 /** A template trait for sequences of type `ParSeq[T]`, representing
  *  parallel sequences with element type `T`.
@@ -67,7 +68,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
 
   def canEqual(other: Any): Boolean = true
 
-  protected[this] type SuperParIterator = IterableSplitter[T]
+  protected[this] type SuperParIterator = IterableSplitter[T @uncheckedVariance]
 
   /** A more refined version of the iterator found in the `ParallelIterable` trait,
    *  this iterator can be split into arbitrary subsets of iterators.
@@ -474,7 +475,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
 
   protected trait ParSeqLikeTransformer[R, Tp] extends ParSeqLikeAccessor[R, Tp] with Transformer[R, Tp]
 
-  protected[this] class SegmentLength(pred: T => Boolean, from: Int, protected[this] val pit: SeqSplitter[T])
+  protected[this] class SegmentLength(pred: T => Boolean, from: Int, protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeAccessor[(Int, Boolean), SegmentLength] {
     @volatile var result: (Int, Boolean) = null
     def leaf(prev: Option[(Int, Boolean)]) = if (from < pit.indexFlag) {
@@ -492,7 +493,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def requiresStrictSplitters = true
   }
 
-  protected[this] class IndexWhere(pred: T => Boolean, from: Int, protected[this] val pit: SeqSplitter[T])
+  protected[this] class IndexWhere(pred: T => Boolean, from: Int, protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeAccessor[Int, IndexWhere] {
     @volatile var result: Int = -1
     def leaf(prev: Option[Int]) = if (from < pit.indexFlag) {
@@ -513,7 +514,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def requiresStrictSplitters = true
   }
 
-  protected[this] class LastIndexWhere(pred: T => Boolean, pos: Int, protected[this] val pit: SeqSplitter[T])
+  protected[this] class LastIndexWhere(pred: T => Boolean, pos: Int, protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeAccessor[Int, LastIndexWhere] {
     @volatile var result: Int = -1
     def leaf(prev: Option[Int]) = if (pos > pit.indexFlag) {
@@ -534,23 +535,23 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def requiresStrictSplitters = true
   }
 
-  protected[this] class Reverse[U >: T, This >: Repr](cbf: () => Combiner[U, This], protected[this] val pit: SeqSplitter[T])
+  protected[this] class Reverse[U >: T, This >: Repr](cbf: () => Combiner[U, This], protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeTransformer[Combiner[U, This], Reverse[U, This]] {
     @volatile var result: Combiner[U, This] = null
     def leaf(prev: Option[Combiner[U, This]]) = result = pit.reverse2combiner(reuse(prev, cbf()))
     protected[this] def newSubtask(p: SuperParIterator) = new Reverse(cbf, down(p))
     override def merge(that: Reverse[U, This]) = result = that.result combine result
   }
 
-  protected[this] class ReverseMap[S, That](f: T => S, pbf: () => Combiner[S, That], protected[this] val pit: SeqSplitter[T])
+  protected[this] class ReverseMap[S, That](f: T => S, pbf: () => Combiner[S, That], protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeTransformer[Combiner[S, That], ReverseMap[S, That]] {
     @volatile var result: Combiner[S, That] = null
     def leaf(prev: Option[Combiner[S, That]]) = result = pit.reverseMap2combiner(f, pbf())
     protected[this] def newSubtask(p: SuperParIterator) = new ReverseMap(f, pbf, down(p))
     override def merge(that: ReverseMap[S, That]) = result = that.result combine result
   }
 
-  protected[this] class SameElements[U >: T](protected[this] val pit: SeqSplitter[T], val otherpit: SeqSplitter[U])
+  protected[this] class SameElements[U >: T](protected[this] val pit: SeqSplitter[T @uncheckedVariance], val otherpit: SeqSplitter[U @uncheckedVariance])
   extends ParSeqLikeAccessor[Boolean, SameElements[U]] {
     @volatile var result: Boolean = true
     def leaf(prev: Option[Boolean]) = if (!pit.isAborted) {
@@ -567,7 +568,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def requiresStrictSplitters = true
   }
 
-  protected[this] class Updated[U >: T, That](pos: Int, elem: U, pbf: CombinerFactory[U, That], protected[this] val pit: SeqSplitter[T])
+  protected[this] class Updated[U >: T, That](pos: Int, elem: U, pbf: CombinerFactory[U, That], protected[this] val pit: SeqSplitter[T @uncheckedVariance])
   extends ParSeqLikeTransformer[Combiner[U, That], Updated[U, That]] {
     @volatile var result: Combiner[U, That] = null
     def leaf(prev: Option[Combiner[U, That]]) = result = pit.updated2combiner(pos, elem, pbf())
@@ -580,7 +581,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def requiresStrictSplitters = true
   }
 
-  protected[this] class ParSeqLikeZip[U >: T, S, That](len: Int, cf: CombinerFactory[(U, S), That], protected[this] val pit: SeqSplitter[T], val otherpit: SeqSplitter[S])
+  protected[this] class ParSeqLikeZip[U >: T, S, That](len: Int, cf: CombinerFactory[(U, S), That], protected[this] val pit: SeqSplitter[T @uncheckedVariance], val otherpit: SeqSplitter[S])
   extends ParSeqLikeTransformer[Combiner[(U, S), That], ParSeqLikeZip[U, S, That]] {
     @volatile var result: Result = null
     def leaf(prev: Option[Result]) = result = pit.zip2combiner[U, S, That](otherpit, cf())
@@ -598,7 +599,7 @@ extends ParIterableLike[T, CC, Repr, Sequential]
     override def merge(that: ParSeqLikeZip[U, S, That]) = result = result combine that.result
   }
 
-  protected[this] class Corresponds[S](corr: (T, S) => Boolean, protected[this] val pit: SeqSplitter[T], val otherpit: SeqSplitter[S])
+  protected[this] class Corresponds[S](corr: (T, S) => Boolean, protected[this] val pit: SeqSplitter[T @uncheckedVariance], val otherpit: SeqSplitter[S])
   extends ParSeqLikeAccessor[Boolean, Corresponds[S]] {
     @volatile var result: Boolean = true
     def leaf(prev: Option[Boolean]) = if (!pit.isAborted) {

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

@@ -18,6 +18,7 @@ import scala.collection.generic.DelegatedSignalling
 import scala.collection.generic.IdleSignalling
 import scala.collection.mutable.Builder
 import scala.collection.parallel.immutable.repetition
+import scala.annotation.unchecked.uncheckedVariance
 
 private[collection] trait RemainsIterator[+T] extends Iterator[T] {
   /** The number of elements this iterator has yet to iterate.
@@ -425,7 +426,7 @@ self =>
     def next() = { remaining -= 1; self.next() }
     def dup: IterableSplitter[T] = self.dup.take(taken)
     def split: Seq[IterableSplitter[T]] = takeSeq(self.split) { (p, n) => p.take(n) }
-    protected[this] def takeSeq[PI <: IterableSplitter[T]](sq: Seq[PI])(taker: (PI, Int) => PI) = {
+    protected[this] def takeSeq[PI <: IterableSplitter[T @uncheckedVariance]](sq: Seq[PI])(taker: (PI, Int) => PI) = {
       val sizes = sq.scanLeft(0)(_ + _.remaining)
       val shortened = for ((it, (from, until)) <- sq zip (sizes.init zip sizes.tail)) yield
         if (until < remaining) it else taker(it, remaining - from)

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

@@ -15,7 +15,6 @@ package collection
 
 import scala.collection.parallel.mutable.ParArray
 import scala.collection.mutable.UnrolledBuffer
-import scala.annotation.unchecked.uncheckedVariance
 import scala.language.implicitConversions
 
 /** Package object for parallel collections.
@@ -168,7 +167,7 @@ package parallel {
   (private val bucketnumber: Int)
   extends Combiner[Elem, To] {
   //self: EnvironmentPassingCombiner[Elem, To] =>
-    protected var buckets: Array[UnrolledBuffer[Buck]] @uncheckedVariance = new Array[UnrolledBuffer[Buck]](bucketnumber)
+    protected var buckets: Array[UnrolledBuffer[Buck]] = new Array[UnrolledBuffer[Buck]](bucketnumber)
     protected var sz: Int = 0
 
     def size = sz