Be more explicit about usage of unsound language features

Subset of scala/collection-strawman#521 containing only changes applied
to the collections-contrib module. The other changes have already
been ported to scala/scala#6508.

Author: julienrf

src/main/scala/scala/collection/MultiDict.scala

@@ -1,5 +1,7 @@
 package scala.collection
 
+import annotation.unchecked.uncheckedVariance
+
 /**
   * A multidict is a map that can associate a set of values to a given key.
   *
@@ -40,7 +42,7 @@ trait MultiDict[K, V]
 trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
   extends IterableOps[(K, V), Iterable, C] {
 
-  protected[this] type MultiDictCC[K, V] = CC[K, V]
+  protected[this] type MultiDictCC[K, V] = CC[K, V] @uncheckedVariance
 
   def multiMapFactory: MapFactory[MultiDictCC]
 
@@ -133,13 +135,8 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
   def concat(that: Iterable[(K, V)]): C =
     fromSpecificIterable(new View.Concat(toIterable, that))
 
-  override def withFilter(p: ((K, V)) => Boolean): MultiMapWithFilter = new MultiMapWithFilter(p)
-
-  class MultiMapWithFilter(p: ((K, V)) => Boolean) extends WithFilter(p) {
-    def map[L, W](f: ((K, V)) => (L, W)): CC[L, W] = multiMapFromIterable(new View.Map(filtered, f))
-    def flatMap[L, W](f: ((K, V)) => IterableOnce[(L, W)]): CC[L, W] = multiMapFromIterable(new View.FlatMap(filtered, f))
-    override def withFilter(q: ((K, V)) => Boolean): MultiMapWithFilter = new MultiMapWithFilter(kv => p(kv) && q(kv))
-  }
+  override def withFilter(p: ((K, V)) => Boolean): MultiDictOps.WithFilter[K, V, IterableCC, CC] =
+    new MultiDictOps.WithFilter(this, p)
 
   /**
     * @return Whether there exists a value associated with the given `key`
@@ -203,4 +200,23 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
 
 }
 
-object MultiDict extends MapFactory.Delegate[MultiDict](immutable.MultiDict)
+object MultiDictOps {
+
+  class WithFilter[K, V, +IterableCC[_], +CC[X, Y] <: MultiDict[X, Y]](
+    `this`: MultiDictOps[K, V, CC, _] with IterableOps[(K, V), IterableCC, _],
+    p: ((K, V)) => Boolean
+  ) extends IterableOps.WithFilter[(K, V), IterableCC](`this`, p) {
+
+    def map[L, W](f: ((K, V)) => (L, W)): CC[L, W] =
+      `this`.multiMapFactory.from(new View.Map(filtered, f))
+
+    def flatMap[L, W](f: ((K, V)) => IterableOnce[(L, W)]): CC[L, W] =
+      `this`.multiMapFactory.from(new View.FlatMap(filtered, f))
+
+    override def withFilter(q: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, CC] =
+      new WithFilter[K, V, IterableCC, CC](`this`, (kv: (K, V)) => p(kv) && q(kv))
+  }
+
+}
+
+object MultiDict extends MapFactory.Delegate[MultiDict](immutable.MultiDict)

src/main/scala/scala/collection/SortedMultiDict.scala

@@ -1,8 +1,9 @@
 package scala.collection
 
+import annotation.unchecked.uncheckedVariance
+
 /**
   * A multidict whose keys are sorted
- *
   * @tparam K the type of keys
   * @tparam V the type of values
   */
@@ -20,7 +21,7 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
   extends MultiDictOps[K, V, MultiDict, C]
     with SortedOps[K, C] {
 
-  protected[this] type SortedMultiDictCC[K, V] = CC[K, V]
+  protected[this] type SortedMultiDictCC[K, V] = CC[K, V] @uncheckedVariance
 
   def sortedMultiMapFactory: SortedMapFactory[SortedMultiDictCC]
 
@@ -51,13 +52,8 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
       until(next)
   }
 
-  override def withFilter(p: ((K, V)) => Boolean): SortedMultiMapWithFilter = new SortedMultiMapWithFilter(p)
-
-  class SortedMultiMapWithFilter(p: ((K, V)) => Boolean) extends MultiMapWithFilter(p) {
-    def map[L : Ordering, W](f: ((K, V)) => (L, W)): CC[L, W] = sortedFromIterable(new View.Map(filtered, f))
-    def flatMap[L : Ordering, W](f: ((K, V)) => IterableOnce[(L, W)]): CC[L, W] = sortedFromIterable(new View.FlatMap(filtered, f))
-    override def withFilter(q: ((K, V)) => Boolean): SortedMultiMapWithFilter = new SortedMultiMapWithFilter(kv => p(kv) && q(kv))
-  }
+  override def withFilter(p: ((K, V)) => Boolean): SortedMultiDictOps.WithFilter[K, V, IterableCC, MultiDictCC, CC] =
+    new SortedMultiDictOps.WithFilter[K, V, IterableCC, MultiDictCC, CC](this, p)
 
   /**
     * @return a sorted multidict that contains all the entries of `this` sorted multidict,
@@ -130,4 +126,24 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
 
 }
 
-object SortedMultiDict extends SortedMapFactory.Delegate[SortedMultiDict](immutable.SortedMultiDict)
+object SortedMultiDictOps {
+
+  class WithFilter[K, V, +IterableCC[_], +MultiDictCC[X, Y] <: MultiDict[X, Y], +CC[X, Y] <: MultiDict[X, Y]](
+    `this`: SortedMultiDictOps[K, V, CC, _] with MultiDictOps[K, V, MultiDictCC, _] with IterableOps[(K, V), IterableCC, _],
+    p: ((K, V)) => Boolean
+  ) extends MultiDictOps.WithFilter[K, V, IterableCC, MultiDictCC](`this`, p) {
+
+    def map[L : Ordering, W](f: ((K, V)) => (L, W)): CC[L, W] =
+      `this`.sortedMultiMapFactory.from(new View.Map(filtered, f))
+
+    def flatMap[L : Ordering, W](f: ((K, V)) => IterableOnce[(L, W)]): CC[L, W] =
+      `this`.sortedMultiMapFactory.from(new View.FlatMap(filtered, f))
+
+    override def withFilter(q: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, MultiDictCC, CC] =
+      new WithFilter[K, V, IterableCC, MultiDictCC, CC](`this`, kv => p(kv) && q(kv))
+
+  }
+
+}
+
+object SortedMultiDict extends SortedMapFactory.Delegate[SortedMultiDict](immutable.SortedMultiDict)

src/main/scala/scala/collection/SortedMultiSet.scala

@@ -24,7 +24,7 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   extends MultiSetOps[A, MultiSet, C]
     with SortedOps[A, C] {
 
-  protected[this] type SortedIterableCC[X] = CC[X]
+  protected[this] type SortedIterableCC[X] = CC[X] @uncheckedVariance
 
   def sortedIterableFactory: SortedIterableFactory[SortedIterableCC]
 
@@ -62,21 +62,8 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
       until(next)
   }
 
-  override def withFilter(p: A => Boolean): SortedWithFilter = new SortedWithFilter(p)
-
-  /** Specialize `WithFilter` for sorted collections
-    *
-    * @define coll sorted collection
-    */
-  class SortedWithFilter(p: A => Boolean) extends WithFilter(p) {
-
-    def map[B : Ordering](f: A => B): CC[B] = sortedIterableFactory.from(new View.Map(filtered, f))
-
-    def flatMap[B : Ordering](f: A => IterableOnce[B]): CC[B] = sortedIterableFactory.from(new View.FlatMap(filtered, f))
-
-    override def withFilter(q: A => Boolean): SortedWithFilter = new SortedWithFilter(a => p(a) && q(a))
-
-  }
+  override def withFilter(p: A => Boolean): SortedMultiSetOps.WithFilter[A, IterableCC, CC] =
+    new SortedMultiSetOps.WithFilter(this, p)
 
   /** Builds a new sorted multiset by applying a function to all elements of this sorted multiset.
     *
@@ -169,4 +156,28 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
 
 }
 
+object SortedMultiSetOps {
+
+  /** Specialize `WithFilter` for sorted collections
+    *
+    * @define coll sorted collection
+    */
+  class WithFilter[A, +IterableCC[_], +CC[X] <: MultiSet[X]](
+    `this`: SortedMultiSetOps[A, CC, _] with IterableOps[A, IterableCC, _],
+    p: A => Boolean
+  ) extends IterableOps.WithFilter(`this`, p) {
+
+    def map[B : Ordering](f: A => B): CC[B] =
+      `this`.sortedIterableFactory.from(new View.Map(filtered, f))
+
+    def flatMap[B : Ordering](f: A => IterableOnce[B]): CC[B] =
+      `this`.sortedIterableFactory.from(new View.FlatMap(filtered, f))
+
+    override def withFilter(q: A => Boolean): WithFilter[A, IterableCC, CC] =
+      new WithFilter[A, IterableCC, CC](`this`, a => p(a) && q(a))
+
+  }
+
+}
+
 object SortedMultiSet extends SortedIterableFactory.Delegate(immutable.SortedMultiSet)