Make Set covariant, create InvariantSetOps

As a first step, we make Set and immutable.Set covariant, but keep their
operations as-is, annotated with @UV to typecheck. We also create
InvariantSetOps and immutable.InvariantSetOps that we will use in
subsequent commits to hold the operations that only make sense on
invariant subclasses of Set. Note that currently, the only non-mutable
Sets that must be invariant are the SortedSets, so we could fusion
InvariantSetOps with SortedSetOps to reduce the API at the cost of some
flexibility.

Author: smarter

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -166,7 +166,7 @@ abstract class Erasure extends InfoTransform
    * This is important on Android because there is otherwise an interface explosion.
    */
   def minimizeParents(cls: Symbol, parents: List[Type]): List[Type] = if (parents.isEmpty) parents else {
-    val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty)
+    val requiredDirect: Symbol => Boolean = requiredDirectInterfaces.getOrElse(cls, Set.empty).contains
     var rest   = parents.tail
     var leaves = collection.mutable.ListBuffer.empty[Type] += parents.head
     while (rest.nonEmpty) {

src/library/scala/collection/InvariantSetOps.scala

@@ -0,0 +1,8 @@
+package scala
+package collection
+
+import scala.language.higherKinds
+
+trait InvariantSetOps[A, +CC[X] <: InvariantSetOps[X, CC, _] with Set[X], +C <: InvariantSetOps[A, CC, C] with CC[A]]
+  extends SetOps[A, Set, C] {
+}

src/library/scala/collection/Set.scala

@@ -1,14 +1,14 @@
 package scala
 package collection
 
-import scala.annotation.unchecked.uncheckedVariance
+import scala.annotation.unchecked.{uncheckedVariance => uV}
 import scala.language.higherKinds
 import scala.util.hashing.MurmurHash3
 import java.lang.String
 
 /** Base trait for set collections.
   */
-trait Set[A]
+trait Set[+A]
   extends Iterable[A]
     with SetOps[A, Set, Set[A]]
     with Equals {
@@ -29,19 +29,18 @@ trait Set[A]
 
   override def iterableFactory: IterableFactory[IterableCC] = Set
 
-  def empty: IterableCC[A] = iterableFactory.empty
+  def empty: IterableCC[A] @uV = iterableFactory.empty
 }
 
 /** Base trait for set operations
   *
   * @define coll set
   * @define Coll `Set`
   */
-trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] with CC[A]]
-  extends IterableOps[A, CC, C]
-     with (A => Boolean) {
+trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] with CC[A]]
+  extends IterableOps[A, CC, C] {
 
-  def contains(elem: A): Boolean
+  def contains(elem: A @uV): Boolean
 
   /** Tests if some element is contained in this set.
     *
@@ -50,15 +49,15 @@ trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] w
     *  @return  `true` if `elem` is contained in this set, `false` otherwise.
     */
   @deprecatedOverriding("This method should be final, but is not due to scala/bug#10853", "2.13.0")
-  /*@`inline` final*/ def apply(elem: A): Boolean = this.contains(elem)
+  /*@`inline` final*/ def apply(elem: A @uV): Boolean = this.contains(elem)
 
   /** Tests whether this set is a subset of another set.
     *
     *  @param that  the set to test.
     *  @return     `true` if this set is a subset of `that`, i.e. if
     *              every element of this set is also an element of `that`.
     */
-  def subsetOf(that: Set[A]): Boolean = this.forall(that)
+  def subsetOf(that: Set[A @uV]): Boolean = this.forall(that)
 
   /** An iterator over all subsets of this set of the given size.
     *  If the requested size is impossible, an empty iterator is returned.
@@ -136,30 +135,31 @@ trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] w
     *  @return  a new set consisting of all elements that are both in this
     *  set and in the given set `that`.
     */
-  def intersect(that: Set[A]): C = this.filter(that)
+  def intersect(that: Set[A @uV]): C = this.filter(that)
 
   /** Alias for `intersect` */
-  @`inline` final def & (that: Set[A]): C = intersect(that)
+  @`inline` final def & (that: Set[A @uV]): C = intersect(that)
+
 
   /** Computes the difference of this set and another set.
     *
     *  @param that the set of elements to exclude.
     *  @return     a set containing those elements of this
     *              set that are not also contained in the given set `that`.
     */
-  def diff(that: Set[A]): C = this.filterNot(that)
+  def diff(that: Set[A @uV]): C = this.filterNot(that)
 
   /** Alias for `diff` */
-  @`inline` final def &~ (that: Set[A]): C = this diff that
+  @`inline` final def &~ (that: Set[A @uV]): C = this diff that
 
   @deprecated("Use &~ or diff instead of --", "2.13.0")
-  @`inline` final def -- (that: Set[A]): C = diff(that)
+  @`inline` final def -- (that: Set[A @uV]): C = diff(that)
 
   @deprecated("Consider requiring an immutable Set or fall back to Set.diff", "2.13.0")
-  def - (elem: A): C = diff(Set(elem))
+  def - (elem: A @uV): C = diff(Set(elem))
 
   @deprecated("Use &- with an explicit collection argument instead of - with varargs", "2.13.0")
-  def - (elem1: A, elem2: A, elems: A*): C = diff(elems.toSet + elem1 + elem2)
+  def - (elem1: A @uV, elem2: A @uV, elems: (A @uV)*): C = diff(elems.toSet + elem1 + elem2)
 
   /** Creates a new $coll by adding all elements contained in another collection to this $coll, omitting duplicates.
     *
@@ -174,27 +174,27 @@ trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] w
     *  @param that     the collection containing the elements to add.
     *  @return a new $coll with the given elements added, omitting duplicates.
     */
-  def concat(that: collection.Iterable[A]): C = fromSpecificIterable(new View.Concat(toIterable, that))
+  def concat(that: collection.Iterable[A @uV]): C = fromSpecificIterable(new View.Concat(toIterable, that))
 
   @deprecated("Consider requiring an immutable Set or fall back to Set.union", "2.13.0")
-  def + (elem: A): C = fromSpecificIterable(new View.Appended(toIterable, elem))
+  def + (elem: A @uV): C = fromSpecificIterable(new View.Appended(toIterable, elem))
 
   @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
-  def + (elem1: A, elem2: A, elems: A*): C = fromSpecificIterable(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))
+  def + (elem1: A @uV, elem2: A @uV, elems: (A @uV)*): C = fromSpecificIterable(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))
 
   /** Alias for `concat` */
-  @`inline` final def ++ (that: collection.Iterable[A]): C = concat(that)
+  @`inline` final def ++ (that: collection.Iterable[A @uV]): C = concat(that)
 
   /** Computes the union between of set and another set.
     *
     *  @param   that  the set to form the union with.
     *  @return  a new set consisting of all elements that are in this
     *  set or in the given set `that`.
     */
-  @`inline` final def union(that: collection.Iterable[A]): C = concat(that)
+  @`inline` final def union(that: collection.Iterable[A @uV]): C = concat(that)
 
   /** Alias for `union` */
-  @`inline` final def | (that: collection.Iterable[A]): C = concat(that)
+  @`inline` final def | (that: collection.Iterable[A @uV]): C = concat(that)
 
   /** The empty set of the same type as this set
     * @return  an empty set of type `C`.
@@ -208,8 +208,10 @@ trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] w
   * @define Coll `Set`
   */
 @SerialVersionUID(3L)
-object Set extends IterableFactory.Delegate[Set](immutable.Set)
+object Set extends IterableFactory.Delegate[Set](immutable.Set) {
+  implicit def setToFunction[A](set: Set[A]): A => Boolean = set.contains
+}
 
 /** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */
 @SerialVersionUID(3L)
-abstract class AbstractSet[A] extends AbstractIterable[A] with Set[A]
+abstract class AbstractSet[+A] extends AbstractIterable[A] with Set[A]

src/library/scala/collection/SortedSet.scala

@@ -27,7 +27,7 @@ trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
 }
 
 trait SortedSetOps[A, +CC[X] <: SortedSetOps[X, CC, _] with SortedSet[X], +C <: SortedSetOps[A, CC, C] with CC[A]]
-  extends SetOps[A, Set, C]
+  extends InvariantSetOps[A, CC, C]
      with SortedOps[A, C] {
 
   /**

src/library/scala/collection/convert/AsJavaConverters.scala

@@ -179,7 +179,7 @@ trait AsJavaConverters {
    */
   def setAsJavaSet[A](s: Set[A]): ju.Set[A] = s match {
     case null                 => null
-    case JSetWrapper(wrapped) => wrapped
+    case JSetWrapper(wrapped) => wrapped.asInstanceOf[ju.Set[A]]
     case _                    => new SetWrapper(s)
   }
 

src/library/scala/collection/convert/WrapAsJava.scala

@@ -202,7 +202,7 @@ private[convert] trait LowPriorityWrapAsJava {
    */
   implicit def setAsJavaSet[A](s: Set[A]): ju.Set[A] = s match {
     case null                 => null
-    case JSetWrapper(wrapped) => wrapped
+    case JSetWrapper(wrapped) => wrapped.asInstanceOf[ju.Set[A]]
     case _                    => new SetWrapper(s)
   }
 

src/library/scala/collection/convert/Wrappers.scala

@@ -160,7 +160,7 @@ private[collection] trait Wrappers {
         case Some(e) =>
           underlying match {
             case ms: mutable.Set[a] =>
-              ms remove e
+              ms.remove(e.asInstanceOf[a])
               prev = None
             case _ =>
               throw new UnsupportedOperationException("remove")

src/library/scala/collection/immutable/ChampHashSet.scala

@@ -21,7 +21,7 @@ import java.lang.System.arraycopy
   */
 final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val cachedJavaHashCode: Int, val cachedSize: Int)
   extends AbstractSet[A]
-    with SetOps[A, ChampHashSet, ChampHashSet[A]]
+    with InvariantSetOps[A, ChampHashSet, ChampHashSet[A]]
     with StrictOptimizedIterableOps[A, ChampHashSet, ChampHashSet[A]] {
 
   override def iterableFactory: IterableFactory[ChampHashSet] = ChampHashSet

src/library/scala/collection/immutable/HashSet.scala

@@ -25,7 +25,7 @@ import scala.annotation.tailrec
   */
 sealed abstract class HashSet[A]
   extends AbstractSet[A]
-    with SetOps[A, HashSet, HashSet[A]]
+    with InvariantSetOps[A, HashSet, HashSet[A]]
     with StrictOptimizedIterableOps[A, HashSet, HashSet[A]] {
 
   import HashSet.{bufferSize, LeafHashSet, nullToEmpty}

src/library/scala/collection/immutable/InvariantSetOps.scala

@@ -0,0 +1,10 @@
+package scala
+package collection
+package immutable
+
+import scala.language.higherKinds
+
+trait InvariantSetOps[A, +CC[X] <: InvariantSetOps[X, CC, _] with Set[X], +C <: InvariantSetOps[A, CC, C] with CC[A]]
+  extends collection.InvariantSetOps[A, CC, C]
+     with SetOps[A, Set, C] {
+}

src/library/scala/collection/immutable/ListSet.scala

@@ -30,7 +30,7 @@ import scala.annotation.tailrec
   */
 sealed class ListSet[A]
   extends AbstractSet[A]
-    with SetOps[A, ListSet, ListSet[A]]
+    with InvariantSetOps[A, ListSet, ListSet[A]]
     with StrictOptimizedIterableOps[A, ListSet, ListSet[A]] {
 
   override def className: String = "ListSet"

src/library/scala/collection/immutable/Set.scala

@@ -5,11 +5,12 @@ package immutable
 import java.io.{ObjectInputStream, ObjectOutputStream}
 
 import scala.collection.mutable.{Builder, ImmutableBuilder}
+import scala.annotation.unchecked.{uncheckedVariance => uV}
 import scala.language.higherKinds
 
 
 /** Base trait for immutable set collections */
-trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]] {
+trait Set[+A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[A]] {
   override def iterableFactory: IterableFactory[IterableCC] = Set
 }
 
@@ -18,34 +19,33 @@ trait Set[A] extends Iterable[A] with collection.Set[A] with SetOps[A, Set, Set[
   * @define coll immutable set
   * @define Coll `immutable.Set`
   */
-trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] with CC[A]]
+trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] with CC[A]]
   extends collection.SetOps[A, CC, C] {
-
   /** Creates a new set with an additional element, unless the element is
     *  already present.
     *
     *  @param elem the element to be added
     *  @return a new set that contains all elements of this set and that also
     *          contains `elem`.
     */
-  def incl(elem: A): C
+  def incl(elem: A @uV): C
 
   /** Alias for `incl` */
   @deprecatedOverriding("This method should be final, but is not due to scala/bug#10853", "2.13.0")
-  override /*final*/ def + (elem: A): C = incl(elem) // like in collection.Set but not deprecated
+  override /*final*/ def + (elem: A @uV): C = incl(elem) // like in collection.Set but not deprecated
 
   /** Creates a new set with a given element removed from this set.
     *
     *  @param elem the element to be removed
     *  @return a new set that contains all elements of this set but that does not
     *          contain `elem`.
     */
-  def excl(elem: A): C
+  def excl(elem: A @uV): C
 
   /** Alias for `excl` */
-  /* @`inline` final */ override def - (elem: A): C = excl(elem)
+  /* @`inline` final */ override def - (elem: A @uV): C = excl(elem)
 
-  override def concat(that: collection.Iterable[A]): C = {
+  override def concat(that: collection.Iterable[A @uV]): C = {
     var result: C = coll
     val it = that.iterator
     while (it.hasNext) result = result + it.next()
@@ -224,4 +224,4 @@ object Set extends IterableFactory[Set] {
 
 /** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */
 @SerialVersionUID(3L)
-abstract class AbstractSet[A] extends scala.collection.AbstractSet[A] with Set[A]
+abstract class AbstractSet[+A] extends scala.collection.AbstractSet[A] with Set[A]

src/library/scala/collection/immutable/SortedSet.scala

@@ -18,7 +18,7 @@ trait SortedSet[A]
   * @define Coll `immutable.SortedSet`
   */
 trait SortedSetOps[A, +CC[X] <: SortedSetOps[X, CC, _] with SortedSet[X], +C <: SortedSetOps[A, CC, C] with CC[A]]
-  extends SetOps[A, Set, C]
+  extends InvariantSetOps[A, CC, C]
      with collection.SortedSetOps[A, CC, C]
 
 /**

src/library/scala/collection/mutable/Set.scala

@@ -18,7 +18,7 @@ trait Set[A]
   */
 trait SetOps[A, +CC[X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C] with CC[A]]
   extends IterableOps[A, CC, C]
-    with collection.SetOps[A, CC, C]
+    with collection.InvariantSetOps[A, CC, C]
     with Cloneable[C]
     with Growable[A]
     with Shrinkable[A] {

test/files/neg/found-req-variance.check

@@ -161,13 +161,6 @@ Note: Int <: AnyVal (and Misc.MyData <: Misc.Data[Int]), but class Data is invar
 You may wish to define A as +A instead. (SLS 4.5)
   def f1 = Set[Data[AnyVal]]() + new MyData
                                  ^
-found-req-variance.scala:100: error: type mismatch;
- found   : Set[String]
- required: Set[CharSequence]
-Note: String <: CharSequence, but trait Set is invariant in type A.
-You may wish to investigate a wildcard type such as `_ <: CharSequence`. (SLS 3.2.10)
-    foo(s)
-        ^
 found-req-variance.scala:104: error: type mismatch;
  found   : Misc.Trippy[String,String,String]
  required: Misc.Trippy[Object,Object,Object]
@@ -182,4 +175,4 @@ Note: AnyRef >: String, but trait Map is invariant in type A.
 You may wish to investigate a wildcard type such as `_ >: String`. (SLS 3.2.10)
   def g2 = Set[Map[String, String]]() + Map[AnyRef, String]()
                                                            ^
-28 errors found
+27 errors found

test/files/neg/t8035-deprecated.check

@@ -1,5 +1,5 @@
 t8035-deprecated.scala:2: warning: Adaptation of argument list by inserting () is deprecated: this is unlikely to be what you want.
-        signature: SetOps.apply(elem: A): Boolean
+        signature: SetOps.apply(elem: A @scala.annotation.unchecked.uncheckedVariance): Boolean
   given arguments: <none>
  after adaptation: SetOps((): Unit)
   List(1,2,3).toSet()

test/files/neg/t8035-removed.check

@@ -1,5 +1,5 @@
 t8035-removed.scala:2: error: Adaptation of argument list by inserting () has been removed.
-        signature: SetOps.apply(elem: A): Boolean
+        signature: SetOps.apply(elem: A @scala.annotation.unchecked.uncheckedVariance): Boolean
   given arguments: <none>
   List(1,2,3).toSet()
                    ^

test/files/neg/unchecked.check

@@ -1,9 +1,6 @@
 unchecked.scala:18: warning: non-variable type argument String in type pattern Iterable[String] (the underlying of Iterable[String]) is unchecked since it is eliminated by erasure
     case xs: Iterable[String] => xs.head // unchecked
              ^
-unchecked.scala:22: warning: non-variable type argument Any in type pattern scala.collection.immutable.Set[Any] (the underlying of Set[Any]) is unchecked since it is eliminated by erasure
-    case xs: Set[Any] => xs.head // unchecked
-             ^
 unchecked.scala:26: warning: non-variable type argument Any in type pattern scala.collection.immutable.Map[Any,Any] (the underlying of Map[Any,Any]) is unchecked since it is eliminated by erasure
     case xs: Map[Any, Any] => xs.head // unchecked
              ^
@@ -17,5 +14,5 @@ unchecked.scala:55: warning: non-variable type argument Array[T] in type pattern
     case ArrayApply(x: Exp[Array[T]], _, _) => x // unchecked
                        ^
 error: No warnings can be incurred under -Xfatal-warnings.
-6 warnings found
+5 warnings found
 one error found

test/files/neg/unchecked.scala

@@ -19,7 +19,7 @@ object Test {
     case _                    => 0
   }
   def f3(x: Any) = x match {
-    case xs: Set[Any] => xs.head // unchecked
+    case xs: Set[Any] => xs.head // okay
     case _            => 0
   }
   def f4(x: Any) = x match {

test/files/neg/unchecked3.check

@@ -31,12 +31,9 @@ unchecked3.scala:62: warning: non-variable type argument Array[String] in type p
 unchecked3.scala:63: warning: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure
     /*   warn */ case _: Array[Array[List[String]]] => ()
                          ^
-unchecked3.scala:75: warning: abstract type A in type pattern scala.collection.immutable.Set[Q.this.A] (the underlying of Set[Q.this.A]) is unchecked since it is eliminated by erasure
-      /*   warn */ case xs: Set[A]  => xs.head
-                            ^
 unchecked3.scala:62: warning: unreachable code
     /*   warn */ case _: Array[List[Array[String]]] => ()
                                                        ^
 error: No warnings can be incurred under -Xfatal-warnings.
-13 warnings found
+12 warnings found
 one error found

test/files/neg/unchecked3.scala

@@ -72,7 +72,7 @@ object Matching {
     def f(xs: Iterable[B]) = xs match {
       /* nowarn */ case xs: List[A] => xs.head
       /* nowarn */ case xs: Seq[B]  => xs.head
-      /*   warn */ case xs: Set[A]  => xs.head
+      /* nowarn */ case xs: Set[A]  => xs.head
     }
     def f2[T <: B](xs: Iterable[T]) = xs match {
       /* nowarn */ case xs: List[B with T] => xs.head