fixup! fixup! fixup! Add SeqSet and SetFromMap implementations

all private plus a few comments

Author: NthPortal

src/main/scala/scala/collection/SetFromMapOps.scala

@@ -17,7 +17,13 @@ import scala.annotation.implicitNotFound
 import scala.collection.SetFromMapOps.WrappedMap
 import scala.reflect.ClassTag
 
-trait SetFromMapOps[
+// Implementation note: The `concurrent.Set` implementation
+//   inherits from this, so we have to be careful about
+//   making changes that do more than forward to the
+//   underlying `Map`. If we have a method implementation
+//   that is not atomic, we MUST override that method in
+//   `concurrent.SetFromMap`.
+private trait SetFromMapOps[
     A,
     +MM[K, V] <: MapOps[K, V, MM, _],
     +M <: MapOps[A, Unit, MM, M],
@@ -189,14 +195,15 @@ trait SetFromMapOps[
   override def view: View[A] = underlying.keySet.view
 }
 
-object SetFromMapOps {
+private object SetFromMapOps {
 
   // top type to make pattern matching easier
   sealed trait WrappedMap[A] extends IterableOnce[A] {
     protected[collection] val underlying: IterableOnce[(A, Unit)]
   }
 
-  trait DynamicClassName { self: Iterable[_] =>
+  trait DynamicClassName {
+    self: Iterable[_] =>
     protected[collection] val underlying: Iterable[_]
 
     override protected[this] def className: String = s"SetFrom_${underlying.collectionClassName}"
@@ -302,7 +309,7 @@ object SetFromMapOps {
 
 }
 
-abstract class SetFromMapFactory[+MM[K, V] <: Map[K, V], +CC[A] <: WrappedMap[A]](
+private abstract class SetFromMapFactory[+MM[K, V] <: Map[K, V], +CC[A] <: WrappedMap[A]](
     mf: MapFactory[MM]
 ) extends IterableFactory[CC]
     with Serializable {
@@ -339,9 +346,10 @@ abstract class SetFromMapFactory[+MM[K, V] <: Map[K, V], +CC[A] <: WrappedMap[A]
 
 }
 
-abstract class SortedSetFromMapFactory[+MM[K, V] <: SortedMap[K, V], +CC[A] <: WrappedMap[A]](
-    mf: SortedMapFactory[MM]
-) extends SortedIterableFactory[CC]
+private abstract class SortedSetFromMapFactory[+MM[K, V] <: SortedMap[K, V], +CC[A] <: WrappedMap[
+  A
+]](mf: SortedMapFactory[MM])
+    extends SortedIterableFactory[CC]
     with Serializable {
   protected[this] def fromMap[A: Ordering](map: MM[A, Unit]): CC[A]
 
@@ -376,16 +384,17 @@ abstract class SortedSetFromMapFactory[+MM[K, V] <: SortedMap[K, V], +CC[A] <: W
 
 }
 
-sealed abstract class SetFromMapMetaFactoryBase[MM[K, V] <: Map[K, V], +CC[A] <: Set[A]] {
+private sealed abstract class SetFromMapMetaFactoryBase[MM[K, V] <: Map[K, V], +CC[A] <: Set[A]] {
   def apply[A](map: MM[A, Unit]): CC[A]
 }
 
-abstract class SetFromMapMetaFactory[MM[K, V] <: Map[K, V], +CC[A] <: Set[A]]
+private abstract class SetFromMapMetaFactory[MM[K, V] <: Map[K, V], +CC[A] <: Set[A]]
     extends SetFromMapMetaFactoryBase[MM, CC] {
   def apply(factory: MapFactory[MM]): IterableFactory[CC]
 }
 
-abstract class SortedSetFromMapMetaFactory[MM[K, V] <: SortedMap[K, V], +CC[A] <: SortedSet[A]]
-    extends SetFromMapMetaFactoryBase[MM, CC] {
+private abstract class SortedSetFromMapMetaFactory[MM[K, V] <: SortedMap[K, V], +CC[A] <: SortedSet[
+  A
+]] extends SetFromMapMetaFactoryBase[MM, CC] {
   def apply(factory: SortedMapFactory[MM]): SortedIterableFactory[CC]
 }

src/main/scala/scala/collection/immutable/SetFromMap.scala

@@ -16,7 +16,7 @@ package immutable
 
 import scala.collection.generic.DefaultSerializable
 
-trait SetFromMapOps[
+private trait SetFromMapOps[
     A,
     +MM[K, +V] <: MapOps[K, V, MM, _],
     +M <: MapOps[A, Unit, MM, M],
@@ -29,7 +29,7 @@ trait SetFromMapOps[
   override def removedAll(that: IterableOnce[A]): C = fromSpecificMap(underlying removedAll that)
 }
 
-object SetFromMapOps {
+private object SetFromMapOps {
 
   trait Unsorted[
       A,

src/main/scala/scala/collection/mutable/SetFromMap.scala

@@ -17,7 +17,13 @@ package mutable
 import scala.collection.SetFromMapOps.WrappedMap
 import scala.collection.generic.DefaultSerializable
 
-trait SetFromMapOps[
+// Implementation note: The `concurrent.Set` implementation
+//   inherits from this, so we have to be careful about
+//   making changes that do more than forward to the
+//   underlying `Map`. If we have a method implementation
+//   that is not atomic, we MUST override that method in
+//   `concurrent.SetFromMap`.
+private[collection] trait SetFromMapOps[
     A,
     +MM[K, V] <: MapOps[K, V, MM, _],
     +M <: MapOps[A, Unit, MM, M],
@@ -45,7 +51,8 @@ trait SetFromMapOps[
 
   override def subtractAll(xs: IterableOnce[A]): this.type = { underlying.subtractAll(xs); this }
 
-  override def knownSize: Int = underlying.knownSize
+  // We need to define this explicitly because there's a multiple inheritance diamond
+  override def knownSize: Int = super[SetFromMapOps].knownSize
 }
 
 @SerialVersionUID(3L)