diff --git a/library/src/scala/AnyVal.scala b/library/src/scala/AnyVal.scala
index 79be48d642be..c5135345b353 100644
--- a/library/src/scala/AnyVal.scala
+++ b/library/src/scala/AnyVal.scala
@@ -53,6 +53,6 @@ package scala
  * still must allocate a value class instance at runtime. These limitations and circumstances are
  * explained in greater detail in the [[https://docs.scala-lang.org/overviews/core/value-classes.html Value Classes and Universal Traits]].
  */
-abstract class AnyVal extends Any {
+transparent abstract class AnyVal extends Any {
   def getClass(): Class[_ <: AnyVal] = null
 }
diff --git a/library/src/scala/Product.scala b/library/src/scala/Product.scala
index c0fa80a95ef5..12dcfbb05181 100644
--- a/library/src/scala/Product.scala
+++ b/library/src/scala/Product.scala
@@ -17,7 +17,7 @@ package scala
  *  their subclasses [[scala.Tuple1]] through [[scala.Tuple22]].  In addition,
  *  all case classes implement `Product` with synthetically generated methods.
  */
-trait Product extends Any with Equals {
+transparent trait Product extends Any with Equals {
   /** The size of this product.
     *  @return     for a product `A(x,,1,,, ..., x,,k,,)`, returns `k`
     */
diff --git a/library/src/scala/collection/BitSet.scala b/library/src/scala/collection/BitSet.scala
index a2da58ea3b9b..48b19d692dd0 100644
--- a/library/src/scala/collection/BitSet.scala
+++ b/library/src/scala/collection/BitSet.scala
@@ -82,7 +82,7 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] {
 }
 
 /** Base implementation type of bitsets */
-trait BitSetOps[+C <: BitSet with BitSetOps[C]]
+transparent trait BitSetOps[+C <: BitSet with BitSetOps[C]]
   extends SortedSetOps[Int, SortedSet, C] { self =>
   import BitSetOps._
 
diff --git a/library/src/scala/collection/IndexedSeq.scala b/library/src/scala/collection/IndexedSeq.scala
index 3735755041a3..e2981db75bcd 100644
--- a/library/src/scala/collection/IndexedSeq.scala
+++ b/library/src/scala/collection/IndexedSeq.scala
@@ -32,7 +32,7 @@ trait IndexedSeq[+A] extends Seq[A]
 object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](immutable.IndexedSeq)
 
 /** Base trait for indexed Seq operations */
-trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self =>
+transparent trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self =>
 
   def iterator: Iterator[A] = view.iterator
 
diff --git a/library/src/scala/collection/Iterable.scala b/library/src/scala/collection/Iterable.scala
index 304a87402f79..71f117dcb19d 100644
--- a/library/src/scala/collection/Iterable.scala
+++ b/library/src/scala/collection/Iterable.scala
@@ -131,7 +131,7 @@ trait Iterable[+A] extends IterableOnce[A]
   *  The order in which operations are performed on elements is unspecified
   *  and may be nondeterministic.
   */
-trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with IterableOnceOps[A, CC, C] {
+transparent trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with IterableOnceOps[A, CC, C] {
   /**
     * @return This collection as an `Iterable[A]`. No new collection will be built if `this` is already an `Iterable[A]`.
     */
diff --git a/library/src/scala/collection/IterableOnce.scala b/library/src/scala/collection/IterableOnce.scala
index 36e71277604a..2f66dc65ae2b 100644
--- a/library/src/scala/collection/IterableOnce.scala
+++ b/library/src/scala/collection/IterableOnce.scala
@@ -320,7 +320,7 @@ object IterableOnce {
   * @define exactlyOnce
   *              Each element appears exactly once in the computation.
   */
-trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
+transparent trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A] =>
   /////////////////////////////////////////////////////////////// Abstract methods that must be implemented
 
   /** Produces a $coll containing cumulative results of applying the
diff --git a/library/src/scala/collection/LinearSeq.scala b/library/src/scala/collection/LinearSeq.scala
index 965edecdadc7..03267c44dc3d 100644
--- a/library/src/scala/collection/LinearSeq.scala
+++ b/library/src/scala/collection/LinearSeq.scala
@@ -32,7 +32,7 @@ trait LinearSeq[+A] extends Seq[A]
 object LinearSeq extends SeqFactory.Delegate[LinearSeq](immutable.LinearSeq)
 
 /** Base trait for linear Seq operations */
-trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends Any with SeqOps[A, CC, C] {
+transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]] extends Any with SeqOps[A, CC, C] {
 
   /** @inheritdoc
    *
@@ -259,7 +259,7 @@ trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeq
   }
 }
 
-trait StrictOptimizedLinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with StrictOptimizedLinearSeqOps[A, CC, C]] extends Any with LinearSeqOps[A, CC, C] with StrictOptimizedSeqOps[A, CC, C] {
+transparent trait StrictOptimizedLinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with StrictOptimizedLinearSeqOps[A, CC, C]] extends Any with LinearSeqOps[A, CC, C] with StrictOptimizedSeqOps[A, CC, C] {
   // A more efficient iterator implementation than the default LinearSeqIterator
   override def iterator: Iterator[A] = new AbstractIterator[A] {
     private[this] var current = StrictOptimizedLinearSeqOps.this
diff --git a/library/src/scala/collection/Map.scala b/library/src/scala/collection/Map.scala
index 1b88058d3197..f0fe25749978 100644
--- a/library/src/scala/collection/Map.scala
+++ b/library/src/scala/collection/Map.scala
@@ -98,7 +98,7 @@ trait Map[K, +V]
   */
 // Note: the upper bound constraint on CC is useful only to
 // erase CC to IterableOps instead of Object
-trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
+transparent trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   extends IterableOps[(K, V), Iterable, C]
     with PartialFunction[K, V] {
 
diff --git a/library/src/scala/collection/Seq.scala b/library/src/scala/collection/Seq.scala
index 753d51b6a51d..ed1e4aa5e548 100644
--- a/library/src/scala/collection/Seq.scala
+++ b/library/src/scala/collection/Seq.scala
@@ -74,7 +74,7 @@ object Seq extends SeqFactory.Delegate[Seq](immutable.Seq)
   * @define coll sequence
   * @define Coll `Seq`
   */
-trait SeqOps[+A, +CC[_], +C] extends Any
+transparent trait SeqOps[+A, +CC[_], +C] extends Any
   with IterableOps[A, CC, C] { self =>
 
   override def view: SeqView[A] = new SeqView.Id[A](this)
diff --git a/library/src/scala/collection/Set.scala b/library/src/scala/collection/Set.scala
index bce5974ed5db..1526424fa662 100644
--- a/library/src/scala/collection/Set.scala
+++ b/library/src/scala/collection/Set.scala
@@ -85,7 +85,7 @@ trait Set[A]
   * @define coll set
   * @define Coll `Set`
   */
-trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
+transparent trait SetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   extends IterableOps[A, CC, C]
      with (A => Boolean) {
 
diff --git a/library/src/scala/collection/SortedMap.scala b/library/src/scala/collection/SortedMap.scala
index d2ccb9e38aa9..76a56557ba66 100644
--- a/library/src/scala/collection/SortedMap.scala
+++ b/library/src/scala/collection/SortedMap.scala
@@ -47,7 +47,7 @@ trait SortedMap[K, +V]
   }
 }
 
-trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
+transparent trait SortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends MapOps[K, V, Map, C]
      with SortedOps[K, C] {
 
diff --git a/library/src/scala/collection/SortedOps.scala b/library/src/scala/collection/SortedOps.scala
index bd034fbf14d6..3e51fa7af0f5 100644
--- a/library/src/scala/collection/SortedOps.scala
+++ b/library/src/scala/collection/SortedOps.scala
@@ -14,7 +14,7 @@ package scala.collection
 
 
 /** Base trait for sorted collections */
-trait SortedOps[A, +C] {
+transparent trait SortedOps[A, +C] {
 
   def ordering: Ordering[A]
 
diff --git a/library/src/scala/collection/SortedSet.scala b/library/src/scala/collection/SortedSet.scala
index 37c28c260000..0cf667d7f46e 100644
--- a/library/src/scala/collection/SortedSet.scala
+++ b/library/src/scala/collection/SortedSet.scala
@@ -45,7 +45,7 @@ trait SortedSet[A] extends Set[A]
 
 }
 
-trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SetOps[A, Set, C]
      with SortedOps[A, C] {
 
diff --git a/library/src/scala/collection/StrictOptimizedIterableOps.scala b/library/src/scala/collection/StrictOptimizedIterableOps.scala
index 3260c1bc262e..8c640c1b7a88 100644
--- a/library/src/scala/collection/StrictOptimizedIterableOps.scala
+++ b/library/src/scala/collection/StrictOptimizedIterableOps.scala
@@ -24,7 +24,7 @@ import scala.runtime.Statics
   * @tparam CC Collection type constructor
   * @tparam C  Collection type
   */
-trait StrictOptimizedIterableOps[+A, +CC[_], +C]
+transparent trait StrictOptimizedIterableOps[+A, +CC[_], +C]
   extends Any
     with IterableOps[A, CC, C] {
 
diff --git a/library/src/scala/collection/StrictOptimizedMapOps.scala b/library/src/scala/collection/StrictOptimizedMapOps.scala
index a87ba3ee9e20..69a2f738655c 100644
--- a/library/src/scala/collection/StrictOptimizedMapOps.scala
+++ b/library/src/scala/collection/StrictOptimizedMapOps.scala
@@ -20,7 +20,7 @@ package scala.collection
   * @tparam CC Collection type constructor
   * @tparam C  Collection type
   */
-trait StrictOptimizedMapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
+transparent trait StrictOptimizedMapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
   extends MapOps[K, V, CC, C]
     with StrictOptimizedIterableOps[(K, V), Iterable, C] {
 
diff --git a/library/src/scala/collection/StrictOptimizedSeqOps.scala b/library/src/scala/collection/StrictOptimizedSeqOps.scala
index a131498d8b28..a255803ade60 100644
--- a/library/src/scala/collection/StrictOptimizedSeqOps.scala
+++ b/library/src/scala/collection/StrictOptimizedSeqOps.scala
@@ -16,7 +16,7 @@ package scala.collection
   * Trait that overrides operations on sequences in order
   * to take advantage of strict builders.
   */
-trait StrictOptimizedSeqOps [+A, +CC[_], +C]
+transparent trait StrictOptimizedSeqOps [+A, +CC[_], +C]
   extends Any
     with SeqOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
diff --git a/library/src/scala/collection/StrictOptimizedSetOps.scala b/library/src/scala/collection/StrictOptimizedSetOps.scala
index 39e585324f45..6b6c2a2c4e27 100644
--- a/library/src/scala/collection/StrictOptimizedSetOps.scala
+++ b/library/src/scala/collection/StrictOptimizedSetOps.scala
@@ -19,7 +19,7 @@ package scala.collection
   * @tparam CC Collection type constructor
   * @tparam C  Collection type
   */
-trait StrictOptimizedSetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
+transparent trait StrictOptimizedSetOps[A, +CC[_], +C <: SetOps[A, CC, C]]
   extends SetOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
 
diff --git a/library/src/scala/collection/StrictOptimizedSortedMapOps.scala b/library/src/scala/collection/StrictOptimizedSortedMapOps.scala
index 8317913c6d1b..2fbcd984e3d3 100644
--- a/library/src/scala/collection/StrictOptimizedSortedMapOps.scala
+++ b/library/src/scala/collection/StrictOptimizedSortedMapOps.scala
@@ -22,7 +22,7 @@ import scala.annotation.implicitNotFound
   * @tparam CC Collection type constructor
   * @tparam C  Collection type
   */
-trait StrictOptimizedSortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
+transparent trait StrictOptimizedSortedMapOps[K, +V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends SortedMapOps[K, V, CC, C]
     with StrictOptimizedMapOps[K, V, Map, C] {
 
diff --git a/library/src/scala/collection/StrictOptimizedSortedSetOps.scala b/library/src/scala/collection/StrictOptimizedSortedSetOps.scala
index c01b0d8466f3..dc56b2438698 100644
--- a/library/src/scala/collection/StrictOptimizedSortedSetOps.scala
+++ b/library/src/scala/collection/StrictOptimizedSortedSetOps.scala
@@ -23,7 +23,7 @@ import scala.annotation.unchecked.uncheckedVariance
   * @tparam CC Collection type constructor
   * @tparam C  Collection type
   */
-trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+transparent trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SortedSetOps[A, CC, C]
     with StrictOptimizedSetOps[A, Set, C] {
 
diff --git a/library/src/scala/collection/generic/DefaultSerializationProxy.scala b/library/src/scala/collection/generic/DefaultSerializationProxy.scala
index 2e584eaa427d..0fcd24547ce4 100644
--- a/library/src/scala/collection/generic/DefaultSerializationProxy.scala
+++ b/library/src/scala/collection/generic/DefaultSerializationProxy.scala
@@ -74,7 +74,7 @@ private[collection] case object SerializeEnd
   * it directly without using this trait if you need a non-standard factory or if you want to use a different
   * serialization scheme.
   */
-trait DefaultSerializable extends Serializable { this: scala.collection.Iterable[_] =>
+transparent trait DefaultSerializable extends Serializable { this: scala.collection.Iterable[_] =>
   protected[this] def writeReplace(): AnyRef = {
     val f: Factory[Any, Any] = this match {
       case it: scala.collection.SortedMap[_, _] => it.sortedMapFactory.sortedMapFactory[Any, Any](using it.ordering.asInstanceOf[Ordering[Any]]).asInstanceOf[Factory[Any, Any]]
diff --git a/library/src/scala/collection/generic/IsIterable.scala b/library/src/scala/collection/generic/IsIterable.scala
index 2260f0f2aacb..f8fc55503757 100644
--- a/library/src/scala/collection/generic/IsIterable.scala
+++ b/library/src/scala/collection/generic/IsIterable.scala
@@ -109,7 +109,7 @@ package generic
  * (Note that in practice the `IsIterable[Range]` instance is already provided by
  * the standard library, and it is defined as an `IsSeq[Range]` instance)
  */
-trait IsIterable[Repr] extends IsIterableOnce[Repr] {
+transparent trait IsIterable[Repr] extends IsIterableOnce[Repr] {
 
   /** The type returned by transformation operations that preserve the same elements
     * type (e.g. `filter`, `take`).
@@ -149,7 +149,7 @@ object IsIterable extends IsIterableLowPriority {
 
 }
 
-trait IsIterableLowPriority {
+transparent trait IsIterableLowPriority {
 
   // Makes `IsSeq` instances visible in `IsIterable` companion
   implicit def isSeqLikeIsIterable[Repr](implicit
diff --git a/library/src/scala/collection/generic/IsIterableOnce.scala b/library/src/scala/collection/generic/IsIterableOnce.scala
index 82f0ec8b7332..be6df00c6980 100644
--- a/library/src/scala/collection/generic/IsIterableOnce.scala
+++ b/library/src/scala/collection/generic/IsIterableOnce.scala
@@ -37,7 +37,7 @@ package generic
  *    // == List(2, 4)
  * }}}
  */
-trait IsIterableOnce[Repr] {
+transparent trait IsIterableOnce[Repr] {
 
   /** The type of elements we can traverse over (e.g. `Int`). */
   type A
@@ -61,7 +61,7 @@ object IsIterableOnce extends IsIterableOnceLowPriority {
 
 }
 
-trait IsIterableOnceLowPriority {
+transparent trait IsIterableOnceLowPriority {
 
   // Makes `IsIterable` instance visible in `IsIterableOnce` companion
   implicit def isIterableLikeIsIterableOnce[Repr](implicit
diff --git a/library/src/scala/collection/generic/IsMap.scala b/library/src/scala/collection/generic/IsMap.scala
index 6178b2f2b7ca..bdc2b407a513 100644
--- a/library/src/scala/collection/generic/IsMap.scala
+++ b/library/src/scala/collection/generic/IsMap.scala
@@ -26,7 +26,7 @@ import scala.collection.immutable.{IntMap, LongMap}
   * @see [[scala.collection.generic.IsIterable]]
   * @tparam Repr Collection type (e.g. `Map[Int, String]`)
   */
-trait IsMap[Repr] extends IsIterable[Repr] {
+transparent trait IsMap[Repr] extends IsIterable[Repr] {
 
   /** The type of keys */
   type K
diff --git a/library/src/scala/collection/generic/IsSeq.scala b/library/src/scala/collection/generic/IsSeq.scala
index 73d0cc9762d6..37abc4c9ee91 100644
--- a/library/src/scala/collection/generic/IsSeq.scala
+++ b/library/src/scala/collection/generic/IsSeq.scala
@@ -25,7 +25,7 @@ import scala.reflect.ClassTag
   *
   * @see [[scala.collection.generic.IsIterable]]
   */
-trait IsSeq[Repr] extends IsIterable[Repr] {
+transparent trait IsSeq[Repr] extends IsIterable[Repr] {
 
   @deprecated("'conversion' is now a method named 'apply'", "2.13.0")
   override val conversion: Repr => SeqOps[A, Iterable, C] = apply(_)
diff --git a/library/src/scala/collection/immutable/Map.scala b/library/src/scala/collection/immutable/Map.scala
index 8f372312512e..09ad82547c91 100644
--- a/library/src/scala/collection/immutable/Map.scala
+++ b/library/src/scala/collection/immutable/Map.scala
@@ -59,7 +59,7 @@ trait Map[K, +V]
   * @define coll immutable map
   * @define Coll `immutable.Map`
   */
-trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
+transparent trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
   extends IterableOps[(K, V), Iterable, C]
     with collection.MapOps[K, V, CC, C] {
 
@@ -149,7 +149,7 @@ trait MapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]
 
 }
 
-trait StrictOptimizedMapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
+transparent trait StrictOptimizedMapOps[K, +V, +CC[X, +Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
   extends MapOps[K, V, CC, C]
     with collection.StrictOptimizedMapOps[K, V, CC, C]
     with StrictOptimizedIterableOps[(K, V), Iterable, C] {
diff --git a/library/src/scala/collection/immutable/Seq.scala b/library/src/scala/collection/immutable/Seq.scala
index 81a40c1c375b..7597d204d7ab 100644
--- a/library/src/scala/collection/immutable/Seq.scala
+++ b/library/src/scala/collection/immutable/Seq.scala
@@ -28,7 +28,7 @@ trait Seq[+A] extends Iterable[A]
   * @define coll immutable sequence
   * @define Coll `immutable.Seq`
   */
-trait SeqOps[+A, +CC[_], +C] extends Any with collection.SeqOps[A, CC, C]
+transparent trait SeqOps[+A, +CC[_], +C] extends Any with collection.SeqOps[A, CC, C]
 
 /**
   * $factoryInfo
@@ -117,7 +117,7 @@ object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](Vector) {
 }
 
 /** Base trait for immutable indexed Seq operations */
-trait IndexedSeqOps[+A, +CC[_], +C]
+transparent trait IndexedSeqOps[+A, +CC[_], +C]
   extends SeqOps[A, CC, C]
     with collection.IndexedSeqOps[A, CC, C] {
 
@@ -147,7 +147,7 @@ object LinearSeq extends SeqFactory.Delegate[LinearSeq](List) {
   }
 }
 
-trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]]
+transparent trait LinearSeqOps[+A, +CC[X] <: LinearSeq[X], +C <: LinearSeq[A] with LinearSeqOps[A, CC, C]]
   extends Any with SeqOps[A, CC, C]
     with collection.LinearSeqOps[A, CC, C]
 
diff --git a/library/src/scala/collection/immutable/Set.scala b/library/src/scala/collection/immutable/Set.scala
index e8509b58016e..f1c01082baf0 100644
--- a/library/src/scala/collection/immutable/Set.scala
+++ b/library/src/scala/collection/immutable/Set.scala
@@ -30,7 +30,7 @@ trait Set[A] extends Iterable[A]
   * @define coll immutable set
   * @define Coll `immutable.Set`
   */
-trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
+transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
   extends collection.SetOps[A, CC, C] {
 
   /** Creates a new set with an additional element, unless the element is
@@ -71,7 +71,7 @@ trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
   override final def -- (that: IterableOnce[A]): C = removedAll(that)
 }
 
-trait StrictOptimizedSetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
+transparent trait StrictOptimizedSetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
   extends SetOps[A, CC, C]
     with collection.StrictOptimizedSetOps[A, CC, C]
     with StrictOptimizedIterableOps[A, CC, C] {
diff --git a/library/src/scala/collection/immutable/SortedMap.scala b/library/src/scala/collection/immutable/SortedMap.scala
index 120ae23ae024..084faba1f601 100644
--- a/library/src/scala/collection/immutable/SortedMap.scala
+++ b/library/src/scala/collection/immutable/SortedMap.scala
@@ -83,7 +83,7 @@ trait SortedMap[K, +V]
   override def withDefaultValue[V1 >: V](d: V1): SortedMap[K, V1] = new SortedMap.WithDefault[K, V1](this, _ => d)
 }
 
-trait SortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
+transparent trait SortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends MapOps[K, V, Map, C] with collection.SortedMapOps[K, V, CC, C] { self =>
 
   protected def coll: C with CC[K, V]
@@ -118,7 +118,7 @@ trait SortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _]
   override def transform[W](f: (K, V) => W): CC[K, W] = map({ case (k, v) => (k, f(k, v)) })(ordering)
 }
 
-trait StrictOptimizedSortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
+transparent trait StrictOptimizedSortedMapOps[K, +V, +CC[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends SortedMapOps[K, V, CC, C]
     with collection.StrictOptimizedSortedMapOps[K, V, CC, C]
     with StrictOptimizedMapOps[K, V, Map, C] {
diff --git a/library/src/scala/collection/immutable/SortedSet.scala b/library/src/scala/collection/immutable/SortedSet.scala
index 2eda00ac6b2f..aa5d92de57bc 100644
--- a/library/src/scala/collection/immutable/SortedSet.scala
+++ b/library/src/scala/collection/immutable/SortedSet.scala
@@ -30,14 +30,14 @@ trait SortedSet[A]
   * @define coll immutable sorted set
   * @define Coll `immutable.SortedSet`
   */
-trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SetOps[A, Set, C]
      with collection.SortedSetOps[A, CC, C] {
 
   def unsorted: Set[A]
 }
 
-trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+transparent trait StrictOptimizedSortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SortedSetOps[A, CC, C]
     with collection.StrictOptimizedSortedSetOps[A, CC, C]
     with StrictOptimizedSetOps[A, Set, C] {
diff --git a/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala b/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala
index 90b803d54e70..9426f6678c58 100644
--- a/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala
+++ b/library/src/scala/collection/immutable/StrictOptimizedSeqOps.scala
@@ -18,7 +18,7 @@ import scala.collection.generic.CommonErrors
 
 /** Trait that overrides operations to take advantage of strict builders.
  */
-trait StrictOptimizedSeqOps[+A, +CC[_], +C]
+transparent trait StrictOptimizedSeqOps[+A, +CC[_], +C]
   extends Any
     with SeqOps[A, CC, C]
     with collection.StrictOptimizedSeqOps[A, CC, C]
diff --git a/library/src/scala/collection/mutable/ArrayDeque.scala b/library/src/scala/collection/mutable/ArrayDeque.scala
index ca70f31d1869..9a01463782e3 100644
--- a/library/src/scala/collection/mutable/ArrayDeque.scala
+++ b/library/src/scala/collection/mutable/ArrayDeque.scala
@@ -568,7 +568,7 @@ object ArrayDeque extends StrictOptimizedSeqFactory[ArrayDeque] {
   }
 }
 
-trait ArrayDequeOps[A, +CC[_], +C <: AnyRef] extends StrictOptimizedSeqOps[A, CC, C] {
+transparent trait ArrayDequeOps[A, +CC[_], +C <: AnyRef] extends StrictOptimizedSeqOps[A, CC, C] {
   protected def array: Array[AnyRef]
 
   final override def clone(): C = klone()
diff --git a/library/src/scala/collection/mutable/IndexedSeq.scala b/library/src/scala/collection/mutable/IndexedSeq.scala
index 464bc00d45db..2c329229ce1a 100644
--- a/library/src/scala/collection/mutable/IndexedSeq.scala
+++ b/library/src/scala/collection/mutable/IndexedSeq.scala
@@ -24,7 +24,7 @@ trait IndexedSeq[T] extends Seq[T]
 @SerialVersionUID(3L)
 object IndexedSeq extends SeqFactory.Delegate[IndexedSeq](ArrayBuffer)
 
-trait IndexedSeqOps[A, +CC[_], +C <: AnyRef]
+transparent trait IndexedSeqOps[A, +CC[_], +C <: AnyRef]
   extends scala.collection.IndexedSeqOps[A, CC, C]
     with SeqOps[A, CC, C] {
 
diff --git a/library/src/scala/collection/mutable/Map.scala b/library/src/scala/collection/mutable/Map.scala
index 8659b45e86e6..b6107318ac16 100644
--- a/library/src/scala/collection/mutable/Map.scala
+++ b/library/src/scala/collection/mutable/Map.scala
@@ -62,7 +62,7 @@ trait Map[K, V]
   * @define coll mutable map
   * @define Coll `mutable.Map`
   */
-trait MapOps[K, V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
+transparent trait MapOps[K, V, +CC[X, Y] <: MapOps[X, Y, CC, _], +C <: MapOps[K, V, CC, C]]
   extends IterableOps[(K, V), Iterable, C]
     with collection.MapOps[K, V, CC, C]
     with Cloneable[C]
diff --git a/library/src/scala/collection/mutable/Seq.scala b/library/src/scala/collection/mutable/Seq.scala
index afabb834a63f..1043ef0f8203 100644
--- a/library/src/scala/collection/mutable/Seq.scala
+++ b/library/src/scala/collection/mutable/Seq.scala
@@ -35,7 +35,7 @@ object Seq extends SeqFactory.Delegate[Seq](ArrayBuffer)
   * @define coll mutable sequence
   * @define Coll `mutable.Seq`
   */
-trait SeqOps[A, +CC[_], +C <: AnyRef]
+transparent trait SeqOps[A, +CC[_], +C <: AnyRef]
   extends collection.SeqOps[A, CC, C]
     with Cloneable[C] {
 
diff --git a/library/src/scala/collection/mutable/Set.scala b/library/src/scala/collection/mutable/Set.scala
index cede5411a349..52f7bca3727e 100644
--- a/library/src/scala/collection/mutable/Set.scala
+++ b/library/src/scala/collection/mutable/Set.scala
@@ -28,7 +28,7 @@ trait Set[A]
   * @define coll mutable set
   * @define Coll `mutable.Set`
   */
-trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
+transparent trait SetOps[A, +CC[X], +C <: SetOps[A, CC, C]]
   extends collection.SetOps[A, CC, C]
     with IterableOps[A, CC, C] // only needed so we can use super[IterableOps] below
     with Cloneable[C]
diff --git a/library/src/scala/collection/mutable/SortedMap.scala b/library/src/scala/collection/mutable/SortedMap.scala
index 1884840f91e2..7a654ec44c0c 100644
--- a/library/src/scala/collection/mutable/SortedMap.scala
+++ b/library/src/scala/collection/mutable/SortedMap.scala
@@ -51,7 +51,7 @@ trait SortedMap[K, V]
   override def withDefaultValue(d: V): SortedMap[K, V] = new SortedMap.WithDefault[K, V](this, _ => d)
 }
 
-trait SortedMapOps[K, V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
+transparent trait SortedMapOps[K, V, +CC[X, Y] <: Map[X, Y] with SortedMapOps[X, Y, CC, _], +C <: SortedMapOps[K, V, CC, C]]
   extends collection.SortedMapOps[K, V, CC, C]
     with MapOps[K, V, Map, C] {
 
diff --git a/library/src/scala/collection/mutable/SortedSet.scala b/library/src/scala/collection/mutable/SortedSet.scala
index 7faf70b87cdc..828335eb7f54 100644
--- a/library/src/scala/collection/mutable/SortedSet.scala
+++ b/library/src/scala/collection/mutable/SortedSet.scala
@@ -31,7 +31,7 @@ trait SortedSet[A]
   * @define coll mutable sorted set
   * @define Coll `mutable.SortedSet`
   */
-trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
+transparent trait SortedSetOps[A, +CC[X] <: SortedSet[X], +C <: SortedSetOps[A, CC, C]]
   extends SetOps[A, Set, C]
     with collection.SortedSetOps[A, CC, C] {