Avoid existentials in diff and intersect

to work around scala/bug#10920

Author: szeiger

src/library/scala/collection/ArrayOps.scala

@@ -1477,7 +1477,7 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will not form
     *                part of the result, but any following occurrences will.
     */
-  def diff(that: Seq[_ >: A]): Array[A] = mutable.ArraySeq.make(xs).diff(that).array.asInstanceOf[Array[A]]
+  def diff[B >: A](that: Seq[B]): Array[A] = mutable.ArraySeq.make(xs).diff(that).array.asInstanceOf[Array[A]]
 
   /** Computes the multiset intersection between this array and another sequence.
     *
@@ -1488,7 +1488,7 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will be retained
     *                in the result, but any following occurrences will be omitted.
     */
-  def intersect(that: Seq[_ >: A]): Array[A] = mutable.ArraySeq.make(xs).intersect(that).array.asInstanceOf[Array[A]]
+  def intersect[B >: A](that: Seq[B]): Array[A] = mutable.ArraySeq.make(xs).intersect(that).array.asInstanceOf[Array[A]]
 
   /** Groups elements in fixed size blocks by passing a "sliding window"
     *  over them (as opposed to partitioning them, as is done in grouped.)

src/library/scala/collection/Seq.scala

@@ -804,7 +804,7 @@ trait SeqOps[+A, +CC[_], +C] extends Any
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will not form
     *                part of the result, but any following occurrences will.
     */
-  def diff(that: Seq[_ >: A]): C = {
+  def diff[B >: A](that: Seq[B]): C = {
     val occ = occCounts(that)
     fromSpecific(iterator.filter { x =>
       val ox = occ(x)  // Avoid multiple map lookups
@@ -825,7 +825,7 @@ trait SeqOps[+A, +CC[_], +C] extends Any
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will be retained
     *                in the result, but any following occurrences will be omitted.
     */
-  def intersect(that: Seq[_ >: A]): C = {
+  def intersect[B >: A](that: Seq[B]): C = {
     val occ = occCounts(that)
     fromSpecific(iterator.filter { x =>
       val ox = occ(x)  // Avoid multiple map lookups

src/library/scala/collection/StrictOptimizedSeqOps.scala

@@ -80,7 +80,7 @@ trait StrictOptimizedSeqOps [+A, +CC[_], +C]
     b.result()
   }
 
-  override def diff(that: Seq[_ >: A]): C = {
+  override def diff[B >: A](that: Seq[B]): C = {
     val occ = occCounts(that)
     val b = newSpecificBuilder
     for (x <- this) {
@@ -91,7 +91,7 @@ trait StrictOptimizedSeqOps [+A, +CC[_], +C]
     b.result()
   }
 
-  override def intersect(that: Seq[_ >: A]): C = {
+  override def intersect[B >: A](that: Seq[B]): C = {
     val occ = occCounts(that)
     val b = newSpecificBuilder
     for (x <- this) {

src/library/scala/collection/StringOps.scala

@@ -1346,7 +1346,7 @@ final class StringOps(private val s: String) extends AnyVal {
     *                part of the result, but any following occurrences will.
     */
   @deprecated("Use `s.toSeq.diff(...).unwrap` instead of `s.diff(...)`", "2.13.0")
-  def diff(that: Seq[_ >: Char]): String = new WrappedString(s).diff(that).unwrap
+  def diff[B >: Char](that: Seq[B]): String = new WrappedString(s).diff(that).unwrap
 
   /** Computes the multiset intersection between this string and another sequence.
     *
@@ -1358,7 +1358,7 @@ final class StringOps(private val s: String) extends AnyVal {
     *                in the result, but any following occurrences will be omitted.
     */
   @deprecated("Use `s.toSeq.intersect(...).unwrap` instead of `s.intersect(...)`", "2.13.0")
-  def intersect(that: Seq[_ >: Char]): String = new WrappedString(s).intersect(that).unwrap
+  def intersect[B >: Char](that: Seq[B]): String = new WrappedString(s).intersect(that).unwrap
 
   /** Selects all distinct chars of this string ignoring the duplicates. */
   @deprecated("Use `s.toSeq.distinct.unwrap` instead of `s.distinct`", "2.13.0")

src/library/scala/collection/immutable/LazyList.scala

@@ -616,11 +616,11 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
     if (isEmpty) tl
     else tail.reverseOnto(newLL(sCons(head, tl)))
 
-  override def diff(that: collection.Seq[_ >: A]): LazyList[A] =
+  override def diff[B >: A](that: collection.Seq[B]): LazyList[A] =
     if (knownIsEmpty) LazyList.empty
     else super.diff(that)
 
-  override def intersect(that: collection.Seq[_ >: A]): LazyList[A] =
+  override def intersect[B >: A](that: collection.Seq[B]): LazyList[A] =
     if (knownIsEmpty) LazyList.empty
     else super.intersect(that)