Adapt apply, contains and +/incl for covariant Set

`contains` now takes an extra type parameter to pass variance checks. To
avoid boxing we overload `contains` in BitSet. The implementation of
`contains` in GenKeySet and TreeSet are currently unsafe and hard to
make safe due to erasure, this will have to be resolved before this PR
can be merged.

`+`/`incl` are changed similarly. Additionally, overloaded versions
with their old type signatures are added to InvariantSetOps. This is
crucial for all the SortedSets since adding an element of the same type
should preserve the sorting.

Author: smarter

src/library/scala/Enumeration.scala

@@ -277,7 +277,10 @@ abstract class Enumeration (initial: Int) extends Serializable {
       new ValueSet(nnIds.rangeImpl(from.map(_.id - bottomId), until.map(_.id - bottomId)))
 
     override def empty = ValueSet.empty
-    def contains(v: Value) = nnIds contains (v.id - bottomId)
+    def contains [A1 >: Value](v: A1) = v match {
+      case v: Value => nnIds contains (v.id - bottomId)
+      case _ => false
+    }
     def incl (value: Value) = new ValueSet(nnIds + (value.id - bottomId))
     def excl (value: Value) = new ValueSet(nnIds - (value.id - bottomId))
     def iterator = nnIds.iterator map (id => thisenum.apply(bottomId + id))

src/library/scala/collection/BitSet.scala

@@ -94,6 +94,11 @@ trait BitSetOps[+C <: BitSet with BitSetOps[C]]
 
   def contains(elem: Int): Boolean =
     0 <= elem && (word(elem >> LogWL) & (1L << elem)) != 0L
+  def contains[A1 >: Int](elem: A1): Boolean =
+    elem match {
+      case elem: Int => contains(elem)
+      case _ => false
+    }
 
   def iterator: Iterator[Int] = iteratorFrom(0)
 

src/library/scala/collection/InvariantSetOps.scala

@@ -5,4 +5,25 @@ 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] {
+  def concat(that: collection.Iterable[A]): 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))
+
+  @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))
+
+  /** Alias for `concat` */
+  @`inline` final def ++ (that: collection.Iterable[A]): 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)
+
+  /** Alias for `union` */
+  @`inline` final def | (that: collection.Iterable[A]): C = concat(that)
 }

src/library/scala/collection/Map.scala

@@ -144,7 +144,8 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   /** A generic trait that is reused by keyset implementations */
   protected trait GenKeySet { this: Set[K] =>
     def iterator: Iterator[K] = MapOps.this.keysIterator
-    def contains(key: K): Boolean = MapOps.this.contains(key)
+    // FIXME: unsafe cast
+    def contains[K1 >: K](key: K1): Boolean = MapOps.this.contains(key.asInstanceOf[K])
     override def size: Int = MapOps.this.size
   }
 

src/library/scala/collection/Set.scala

@@ -40,7 +40,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] {
 
-  def contains(elem: A @uV): Boolean
+  def contains[A1 >: A](elem: A1): Boolean
 
   /** Tests if some element is contained in this set.
     *
@@ -49,7 +49,7 @@ trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C]
     *  @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 @uV): Boolean = this.contains(elem)
+  /*@`inline` final*/ def apply[A1 >: A](elem: A1): Boolean = this.contains(elem)
 
   /** Tests whether this set is a subset of another set.
     *
@@ -174,27 +174,24 @@ trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C]
     *  @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 @uV]): C = fromSpecificIterable(new View.Concat(toIterable, that))
+  def concat[B >: A](that: collection.Iterable[B]): CC[B]
 
   @deprecated("Consider requiring an immutable Set or fall back to Set.union", "2.13.0")
-  def + (elem: A @uV): C = fromSpecificIterable(new View.Appended(toIterable, elem))
+  def + [B >: A](elem: B): CC[B] = fromIterable(new View.Appended(toIterable, elem))
 
   @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
-  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 @uV]): C = concat(that)
+  def + [B >: A](elem1: B, elem2: B, elems: B*): CC[B] = fromIterable(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))
 
   /** 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 @uV]): C = concat(that)
+  @`inline` final def union[B >: A](that: collection.Iterable[B]): CC[B] = concat(that)
 
   /** Alias for `union` */
-  @`inline` final def | (that: collection.Iterable[A @uV]): C = concat(that)
+  @`inline` final def | [B >: A](that: collection.Iterable[B]): CC[B] = concat(that)
 
   /** The empty set of the same type as this set
     * @return  an empty set of type `C`.

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

@@ -191,7 +191,7 @@ private[collection] trait Wrappers {
 
     def iterator = underlying.iterator.asScala
 
-    def contains(elem: A): Boolean = underlying.contains(elem)
+    def contains[A1 >: A](elem: A1): Boolean = underlying.contains(elem)
 
     def addOne(elem: A): this.type = { underlying add elem; this }
     def subtractOne(elem: A): this.type = { underlying remove elem; this }

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

@@ -36,7 +36,7 @@ final class ChampHashSet[A] private[immutable] (val rootNode: SetNode[A], val ca
 
   protected[immutable] def reverseIterator: Iterator[A] = new SetReverseIterator[A](rootNode)
 
-  def contains(element: A): Boolean = rootNode.contains(element, computeHash(element), 0)
+  def contains[A1 >: A](element: A1): Boolean = rootNode.contains(element.asInstanceOf[A], computeHash(element), 0)
 
   def incl(element: A): ChampHashSet[A] = {
     val effect = SetEffect[A]()

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

@@ -34,7 +34,7 @@ sealed abstract class HashSet[A]
 
   override def iterableFactory = HashSet
 
-  def contains(elem: A): Boolean = get0(elem, computeHash(elem), 0)
+  def contains[A1 >: A](elem: A1): Boolean = get0(elem.asInstanceOf[A], computeHash(elem), 0)
 
   def incl(elem: A): HashSet[A] = updated0(elem, computeHash(elem), 0)
 

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

@@ -7,4 +7,23 @@ 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] {
+  /** 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
+
+  /** 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 def concat(that: collection.Iterable[A]): C = {
+    var result: C = coll
+    val it = that.iterator
+    while (it.hasNext) result = (result.incl(it.next()))
+    result
+  }
 }

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

@@ -38,7 +38,7 @@ sealed class ListSet[A]
   override def size: Int = 0
   override def isEmpty: Boolean = true
 
-  def contains(elem: A): Boolean = false
+  def contains[A1 >: A](elem: A1): Boolean = false
 
   def incl(elem: A): ListSet[A] = new Node(elem)
   def excl(elem: A): ListSet[A] = this
@@ -71,7 +71,7 @@ sealed class ListSet[A]
 
     override def isEmpty: Boolean = false
 
-    override def contains(e: A) = containsInternal(this, e)
+    override def contains[A1 >: A](e: A1) = containsInternal(this, e.asInstanceOf[A])
 
     @tailrec private[this] def containsInternal(n: ListSet[A], e: A): Boolean =
       !n.isEmpty && (n.elem == e || containsInternal(n.next, e))

src/library/scala/collection/immutable/Map.scala

@@ -117,7 +117,7 @@ trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]
 
   /** The implementation class of the set returned by `keySet` */
   protected class ImmutableKeySet extends AbstractSet[K] with GenKeySet {
-    def incl(elem: K): Set[K] = if (this(elem)) this else empty ++ this + elem
+    override def incl[K1 >: K](elem: K1): Set[K1] = if (this(elem)) this else empty ++ this + elem
     def excl(elem: K): Set[K] = if (this(elem)) empty ++ this - elem else this
   }
 

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

@@ -28,11 +28,11 @@ trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C]
     *  @return a new set that contains all elements of this set and that also
     *          contains `elem`.
     */
-  def incl(elem: A @uV): C
+  def incl[B >: A](elem: B): CC[B] = fromIterable(new View.Appended(toIterable, elem))
 
   /** 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 @uV): C = incl(elem) // like in collection.Set but not deprecated
+  override /*final*/ def + [B >: A](elem: B): CC[B] = incl(elem) // like in collection.Set but not deprecated
 
   /** Creates a new set with a given element removed from this set.
     *
@@ -45,8 +45,8 @@ trait SetOps[+A, +CC[+X] <: SetOps[X, CC, _] with Set[X], +C <: SetOps[A, CC, C]
   /** Alias for `excl` */
   /* @`inline` final */ override def - (elem: A @uV): C = excl(elem)
 
-  override def concat(that: collection.Iterable[A @uV]): C = {
-    var result: C = coll
+  override def concat[B >: A](that: collection.Iterable[B]): CC[B] = {
+    var result: CC[B] = coll
     val it = that.iterator
     while (it.hasNext) result = result + it.next()
     result
@@ -85,8 +85,8 @@ object Set extends IterableFactory[Set] {
   /** An optimized representation for immutable empty sets */
   private object EmptySet extends AbstractSet[Any] {
     override def size: Int = 0
-    def contains(elem: Any): Boolean = false
-    def incl(elem: Any): Set[Any] = new Set1(elem)
+    def contains[A1 >: Any](elem: A1): Boolean = false
+    override def incl[B >: Any](elem: B): Set[B] = new Set1(elem)
     def excl(elem: Any): Set[Any] = this
     def iterator: Iterator[Any] = Iterator.empty
     override def foreach[U](f: Any => U): Unit = ()
@@ -96,8 +96,8 @@ object Set extends IterableFactory[Set] {
   /** An optimized representation for immutable sets of size 1 */
   final class Set1[A] private[collection] (elem1: A) extends AbstractSet[A] with StrictOptimizedIterableOps[A, Set, Set[A]] {
     override def size: Int = 1
-    def contains(elem: A): Boolean = elem == elem1
-    def incl(elem: A): Set[A] =
+    def contains[A1 >: A](elem: A1): Boolean = elem == elem1
+    override def incl[B >: A](elem: B): Set[B] =
       if (contains(elem)) this
       else new Set2(elem1, elem)
     def excl(elem: A): Set[A] =
@@ -118,8 +118,8 @@ object Set extends IterableFactory[Set] {
   /** An optimized representation for immutable sets of size 2 */
   final class Set2[A] private[collection] (elem1: A, elem2: A) extends AbstractSet[A] with StrictOptimizedIterableOps[A, Set, Set[A]] {
     override def size: Int = 2
-    def contains(elem: A): Boolean = elem == elem1 || elem == elem2
-    def incl(elem: A): Set[A] =
+    def contains[A1 >: A](elem: A1): Boolean = elem == elem1 || elem == elem2
+    override def incl[B >: A](elem: B): Set[B] =
       if (contains(elem)) this
       else new Set3(elem1, elem2, elem)
     def excl(elem: A): Set[A] =
@@ -149,10 +149,10 @@ object Set extends IterableFactory[Set] {
   /** An optimized representation for immutable sets of size 3 */
   final class Set3[A] private[collection] (elem1: A, elem2: A, elem3: A) extends AbstractSet[A] with StrictOptimizedIterableOps[A, Set, Set[A]] {
     override def size: Int = 3
-    def contains(elem: A): Boolean =
+    def contains[A1 >: A](elem: A1): Boolean =
       elem == elem1 || elem == elem2 || elem == elem3
-    def incl(elem: A): Set[A] =
-      if (contains(elem)) this
+    override def incl[B >: A](elem: B): Set[B] =
+      if (contains(elem.asInstanceOf[A])) this
       else new Set4(elem1, elem2, elem3, elem)
     def excl(elem: A): Set[A] =
       if (elem == elem1) new Set2(elem2, elem3)
@@ -183,11 +183,11 @@ object Set extends IterableFactory[Set] {
   /** An optimized representation for immutable sets of size 4 */
   final class Set4[A] private[collection] (elem1: A, elem2: A, elem3: A, elem4: A) extends AbstractSet[A] with StrictOptimizedIterableOps[A, Set, Set[A]] {
     override def size: Int = 4
-    def contains(elem: A): Boolean =
+    def contains[A1 >: A](elem: A1): Boolean =
       elem == elem1 || elem == elem2 || elem == elem3 || elem == elem4
-    def incl(elem: A): Set[A] =
-      if (contains(elem)) this
-      else (if (useBaseline) HashSet.empty[A] else ChampHashSet.empty[A]) + elem1 + elem2 + elem3 + elem4 + elem
+    override def incl[B >: A](elem: B): Set[B] =
+      if (contains(elem.asInstanceOf[A])) this
+      else (if (useBaseline) HashSet.empty[B] else ChampHashSet.empty[B]) + elem1 + elem2 + elem3 + elem4 + elem
     def excl(elem: A): Set[A] =
       if (elem == elem1) new Set3(elem2, elem3, elem4)
       else if (elem == elem2) new Set3(elem1, elem3, elem4)

src/library/scala/collection/immutable/TreeSet.scala

@@ -104,7 +104,8 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
     *  @param  elem    the element to check for membership.
     *  @return true, iff `elem` is contained in this set.
     */
-  def contains(elem: A): Boolean = RB.contains(tree, elem)
+  // FIXME: unsafe cast
+  def contains[A1 >: A](elem: A1): Boolean = RB.contains(tree, elem.asInstanceOf[A])
 
   override def range(from: A, until: A): TreeSet[A] = newSet(RB.range(tree, from, until))
 

src/library/scala/collection/mutable/HashSet.scala

@@ -41,7 +41,7 @@ final class HashSet[A]
 
   def clear(): Unit = table.clearTable()
 
-  def contains(elem: A): Boolean = table.containsElem(elem)
+  def contains[A1 >: A](elem: A1): Boolean = table.containsElem(elem.asInstanceOf[A])
 
   def get(elem: A): Option[A] = table.findEntry(elem)
 

src/library/scala/collection/mutable/LinkedHashSet.scala

@@ -60,7 +60,7 @@ class LinkedHashSet[A]
 
   override def size: Int = table.tableSize
 
-  def contains(elem: A): Boolean = table.findEntry(elem) ne null
+  def contains[A1 >: A](elem: A1): Boolean = table.findEntry(elem.asInstanceOf[A]) ne null
 
   def addOne(elem: A): this.type = {
     table.findOrAddEntry(elem, null)

src/library/scala/collection/mutable/TreeSet.scala

@@ -54,7 +54,8 @@ sealed class TreeSet[A] private (tree: RB.Tree[A, Null])(implicit val ordering:
 
   def clear(): Unit = RB.clear(tree)
 
-  def contains(elem: A): Boolean = RB.contains(tree, elem)
+  // FIXME: unsafe cast
+  def contains[A1 >: A](elem: A1): Boolean = RB.contains(tree, elem.asInstanceOf[A])
 
   def get(elem: A): Option[A] = RB.getKey(tree, elem)
 
@@ -124,7 +125,7 @@ sealed class TreeSet[A] private (tree: RB.Tree[A, Null])(implicit val ordering:
     override def rangeImpl(from: Option[A], until: Option[A]): TreeSet[A] =
       new TreeSetProjection(pickLowerBound(from), pickUpperBound(until))
 
-    override def contains(key: A) = isInsideViewBounds(key) && RB.contains(tree, key)
+    override def contains[A1 >: A](key: A1) = isInsideViewBounds(key.asInstanceOf[A]) && RB.contains(tree, key.asInstanceOf[A])
 
     override def iterator = RB.keysIterator(tree, from, until)
     override def iteratorFrom(start: A) = RB.keysIterator(tree, pickLowerBound(Some(start)), until)

src/reflect/scala/reflect/internal/util/WeakHashSet.scala

@@ -148,7 +148,7 @@ final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: D
     tableLoop(0)
   }
 
-  def contains(elem: A): Boolean = findEntry(elem) ne null
+  def contains[A1 >: A](elem: A1): Boolean = findEntry(elem.asInstanceOf[A]) ne null
 
   // from scala.reflect.internal.Set, find an element or null if it isn't contained
   def findEntry(elem: A): A = elem match {

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 @scala.annotation.unchecked.uncheckedVariance): Boolean
+        signature: SetOps.apply[A1 >: A](elem: A1): 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 @scala.annotation.unchecked.uncheckedVariance): Boolean
+        signature: SetOps.apply[A1 >: A](elem: A1): Boolean
   given arguments: <none>
   List(1,2,3).toSet()
                    ^

test/files/pos/virtpatmat_exist1.scala

@@ -10,7 +10,7 @@ class HS[A]
     with StrictOptimizedIterableOps[A, HS, HS[A]]
     with Serializable {
   def get(elem: A): Option[A] = ???
-  def contains(elem: A): Boolean = ???
+  def contains[A1 >: A](elem: A1): Boolean = ???
   def addOne(elem: A): HS.this.type = ???
   def clear(): Unit = ???
   def iterator: Iterator[A] = ???

test/junit/scala/collection/mutable/SetTest.scala

@@ -18,7 +18,7 @@ class SetTest {
 
     override def empty = new MySet(self.empty)
     def iterator = self.iterator
-    def contains(elem: String) = self.contains(elem)
+    def contains[A1 >: String](elem: A1) = self.contains(elem)
     def get(elem: String): Option[String] = self.get(elem)
     def clear(): Unit = self.clear()
   }