Make unified collection serialization opt-in instead of opt-out

Fixes scala/bug#11192

Author: szeiger

src/library/scala/Enumeration.scala

@@ -316,8 +316,6 @@ abstract class Enumeration (initial: Int) extends Serializable {
       super[SortedSet].zip[B](that)
     override def collect[B](pf: PartialFunction[Value, B])(implicit @implicitNotFound(ValueSet.ordMsg) ev: Ordering[B]): SortedIterableCC[B] =
       super[SortedSet].collect[B](pf)
-
-    override protected[this] def writeReplace(): AnyRef = this
   }
 
   /** A factory object for value sets */

src/library/scala/collection/Iterable.scala

@@ -17,7 +17,6 @@ import scala.language.{higherKinds, implicitConversions}
 import scala.annotation.unchecked.uncheckedVariance
 import scala.collection.mutable.Builder
 import scala.collection.View.{LeftPartitionMapped, RightPartitionMapped}
-import scala.collection.generic.DefaultSerializationProxy
 
 /** Base trait for generic collections.
   *
@@ -26,7 +25,7 @@ import scala.collection.generic.DefaultSerializationProxy
   * @define Coll `Iterable`
   * @define coll iterable collection
   */
-trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterable[A]] with Serializable {
+trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterable[A]] {
 
   // The collection itself
   final def toIterable: this.type = this
@@ -50,12 +49,6 @@ trait Iterable[+A] extends IterableOnce[A] with IterableOps[A, Iterable, Iterabl
   @deprecated("Iterable.seq always returns the iterable itself", "2.13.0")
   def seq: this.type = this
 
-  /** Create a proxy for Java serialization. The default implementation will serialize all elements and
-    * deserialize by using a builder for `CC` via `iterableFactory`. Override in subclasses if more data needs
-    * to be preserved or a more efficient implementation is available. Override to return `this` in order to
-    * use self-serialization instead of a proxy. */
-  protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(iterableFactory.iterableFactory, this)
-
   /** Defines the prefix of this object's `toString` representation.
     *
     * It is recommended to return the name of the concrete collection type, but
@@ -866,10 +859,11 @@ object IterableOps {
     *
     * @define coll collection
     */
+  @SerialVersionUID(3L)
   class WithFilter[+A, +CC[_]](
     self: IterableOps[A, CC, _],
     p: A => Boolean
-  ) extends collection.WithFilter[A, CC] {
+  ) extends collection.WithFilter[A, CC] with Serializable {
 
     protected def filtered: Iterable[A] =
       new View.Filter(self, p, isFlipped = false)

src/library/scala/collection/Map.scala

@@ -14,7 +14,7 @@ package scala
 package collection
 
 import scala.annotation.unchecked.uncheckedVariance
-import scala.collection.generic.DefaultSerializationProxy
+import scala.collection.generic.DefaultSerializable
 import scala.collection.mutable.StringBuilder
 import scala.language.higherKinds
 import scala.util.hashing.MurmurHash3
@@ -59,8 +59,6 @@ trait Map[K, +V]
 
   override def hashCode(): Int = MurmurHash3.mapHash(toIterable)
 
-  override protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(mapFactory.mapFactory[K, V], this)
-
   // These two methods are not in MapOps so that MapView is not forced to implement them
   @deprecated("Use - or remove on an immutable Map", "2.13.0")
   def - (key: K): Map[K, V]
@@ -152,7 +150,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
 
   /** The implementation class of the set returned by `keySet`.
     */
-  protected class KeySet extends AbstractSet[K] with GenKeySet {
+  protected class KeySet extends AbstractSet[K] with GenKeySet with DefaultSerializable {
     def diff(that: Set[K]): Set[K] = fromSpecific(view.filterNot(that))
   }
 
@@ -332,10 +330,11 @@ object MapOps {
     *
     * @define coll map collection
     */
+  @SerialVersionUID(3L)
   class WithFilter[K, +V, +IterableCC[_], +CC[_, _] <: IterableOps[_, AnyConstr, _]](
     self: MapOps[K, V, CC, _] with IterableOps[(K, V), IterableCC, _],
     p: ((K, V)) => Boolean
-  ) extends IterableOps.WithFilter[(K, V), IterableCC](self, p) {
+  ) extends IterableOps.WithFilter[(K, V), IterableCC](self, p) with Serializable {
 
     def map[K2, V2](f: ((K, V)) => (K2, V2)): CC[K2, V2] =
       self.mapFactory.from(new View.Map(filtered, f))

src/library/scala/collection/SortedMap.scala

@@ -17,7 +17,6 @@ import scala.annotation.implicitNotFound
 import scala.collection.immutable.TreeMap
 import scala.language.higherKinds
 import scala.annotation.unchecked.uncheckedVariance
-import scala.collection.generic.DefaultSerializationProxy
 
 /** Base type of sorted sets */
 trait SortedMap[K, +V]
@@ -41,8 +40,6 @@ trait SortedMap[K, +V]
 
   override def empty: SortedMapCC[K, V] @uncheckedVariance = sortedMapFactory.empty
 
-  override protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(sortedMapFactory.sortedMapFactory[K, V], this)
-
   override protected[this] def stringPrefix: String = "SortedMap"
 }
 

src/library/scala/collection/SortedSet.scala

@@ -14,7 +14,6 @@ package scala.collection
 
 import scala.annotation.implicitNotFound
 import scala.annotation.unchecked.uncheckedVariance
-import scala.collection.generic.DefaultSerializationProxy
 import scala.language.higherKinds
 
 /** Base type of sorted sets */
@@ -36,8 +35,6 @@ trait SortedSet[A] extends Set[A] with SortedSetOps[A, SortedSet, SortedSet[A]]
 
   override def empty: SortedIterableCC[A] = sortedIterableFactory.empty
 
-  override protected[this] def writeReplace(): AnyRef = new DefaultSerializationProxy(sortedIterableFactory.evidenceIterableFactory[A], this)
-
   override protected[this] def stringPrefix: String = "SortedSet"
 }
 

src/library/scala/collection/View.scala

@@ -24,7 +24,7 @@ import scala.collection.immutable.LazyList
   * @define coll view
   * @define Coll `View`
   */
-trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] {
+trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] with Serializable {
 
   override def view: View[A] = this
 
@@ -36,8 +36,6 @@ trait View[+A] extends Iterable[A] with IterableOps[A, View, View[A]] {
 
   @deprecated("Views no longer know about their underlying collection type; .force always returns an IndexedSeq", "2.13.0")
   @`inline` def force: IndexedSeq[A] = toIndexedSeq
-
-  override protected[this] def writeReplace(): AnyRef = this
 }
 
 /** This object reifies operations on views as case classes

src/library/scala/collection/WithFilter.scala

@@ -22,7 +22,8 @@ import scala.language.higherKinds
   *
   * @define coll collection
   */
-abstract class WithFilter[+A, +CC[_]] {
+@SerialVersionUID(3L)
+abstract class WithFilter[+A, +CC[_]] extends Serializable {
 
   /** Builds a new collection by applying a function to all elements of the
     * `filtered` outer $coll.

src/library/scala/collection/concurrent/TrieMap.scala

@@ -18,6 +18,7 @@ import java.io.{ObjectInputStream, ObjectOutputStream}
 import java.util.concurrent.atomic._
 
 import scala.annotation.tailrec
+import scala.collection.generic.DefaultSerializable
 import scala.collection.immutable.{List, Nil}
 import scala.collection.mutable.GrowableBuilder
 import scala.util.hashing.Hashing
@@ -683,7 +684,8 @@ private[concurrent] case class RDCSS_Descriptor[K, V](old: INode[K, V], expected
 final class TrieMap[K, V] private (r: AnyRef, rtupd: AtomicReferenceFieldUpdater[TrieMap[K, V], AnyRef], hashf: Hashing[K], ef: Equiv[K])
   extends scala.collection.mutable.AbstractMap[K, V]
     with scala.collection.concurrent.Map[K, V]
-    with scala.collection.mutable.MapOps[K, V, TrieMap, TrieMap[K, V]] {
+    with scala.collection.mutable.MapOps[K, V, TrieMap, TrieMap[K, V]]
+    with DefaultSerializable {
 
   private[this] var hashingobj = if (hashf.isInstanceOf[Hashing.Default[_]]) new TrieMap.MangledHashing[K] else hashf
   private[this] var equalityobj = ef

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

@@ -32,7 +32,7 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class IteratorWrapper[A](underlying: Iterator[A]) extends ju.Iterator[A] with ju.Enumeration[A] {
+  case class IteratorWrapper[A](underlying: Iterator[A]) extends ju.Iterator[A] with ju.Enumeration[A] with Serializable {
     def hasNext = underlying.hasNext
     def next() = underlying.next()
     def hasMoreElements = underlying.hasNext
@@ -45,29 +45,29 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class JIteratorWrapper[A](underlying: ju.Iterator[A]) extends AbstractIterator[A] with Iterator[A] {
+  case class JIteratorWrapper[A](underlying: ju.Iterator[A]) extends AbstractIterator[A] with Iterator[A] with Serializable {
     def hasNext = underlying.hasNext
     def next() = underlying.next
   }
 
   @SerialVersionUID(3L)
-  case class JEnumerationWrapper[A](underlying: ju.Enumeration[A]) extends AbstractIterator[A] with Iterator[A] {
+  case class JEnumerationWrapper[A](underlying: ju.Enumeration[A]) extends AbstractIterator[A] with Iterator[A] with Serializable {
     def hasNext = underlying.hasMoreElements
     def next() = underlying.nextElement
   }
 
   @SerialVersionUID(3L)
-  case class IterableWrapper[A](underlying: Iterable[A]) extends ju.AbstractCollection[A] with IterableWrapperTrait[A] { }
+  case class IterableWrapper[A](underlying: Iterable[A]) extends ju.AbstractCollection[A] with IterableWrapperTrait[A] with Serializable { }
 
   @SerialVersionUID(3L)
-  case class JIterableWrapper[A](underlying: jl.Iterable[A]) extends AbstractIterable[A] {
+  case class JIterableWrapper[A](underlying: jl.Iterable[A]) extends AbstractIterable[A] with Serializable{
     def iterator = underlying.iterator.asScala
     override def iterableFactory = mutable.ArrayBuffer
     override def isEmpty: Boolean = !underlying.iterator().hasNext
   }
 
   @SerialVersionUID(3L)
-  case class JCollectionWrapper[A](underlying: ju.Collection[A]) extends AbstractIterable[A] {
+  case class JCollectionWrapper[A](underlying: ju.Collection[A]) extends AbstractIterable[A] with Serializable {
     def iterator = underlying.iterator.asScala
     override def size = underlying.size
     override def knownSize: Int = if (underlying.isEmpty) 0 else super.knownSize
@@ -76,12 +76,12 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class SeqWrapper[A](underlying: Seq[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] {
+  case class SeqWrapper[A](underlying: Seq[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] with Serializable {
     def get(i: Int) = underlying(i)
   }
 
   @SerialVersionUID(3L)
-  case class MutableSeqWrapper[A](underlying: mutable.Seq[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] {
+  case class MutableSeqWrapper[A](underlying: mutable.Seq[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] with Serializable {
     def get(i: Int) = underlying(i)
     override def set(i: Int, elem: A) = {
       val p = underlying(i)
@@ -91,15 +91,15 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class MutableBufferWrapper[A](underlying: mutable.Buffer[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] {
+  case class MutableBufferWrapper[A](underlying: mutable.Buffer[A]) extends ju.AbstractList[A] with IterableWrapperTrait[A] with Serializable {
     def get(i: Int) = underlying(i)
     override def set(i: Int, elem: A) = { val p = underlying(i); underlying(i) = elem; p }
     override def add(elem: A) = { underlying += elem; true }
     override def remove(i: Int) = underlying remove i
   }
 
   @SerialVersionUID(3L)
-  case class JListWrapper[A](underlying: ju.List[A]) extends mutable.AbstractBuffer[A] with SeqOps[A, mutable.Buffer, mutable.Buffer[A]] {
+  case class JListWrapper[A](underlying: ju.List[A]) extends mutable.AbstractBuffer[A] with SeqOps[A, mutable.Buffer, mutable.Buffer[A]] with Serializable {
     def length = underlying.size
     override def knownSize: Int = if (underlying.isEmpty) 0 else super.knownSize
     override def isEmpty = underlying.isEmpty
@@ -179,7 +179,7 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class MutableSetWrapper[A](underlying: mutable.Set[A]) extends SetWrapper[A](underlying) {
+  case class MutableSetWrapper[A](underlying: mutable.Set[A]) extends SetWrapper[A](underlying) with Serializable {
     override def add(elem: A) = {
       val sz = underlying.size
       underlying += elem
@@ -192,7 +192,7 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class JSetWrapper[A](underlying: ju.Set[A]) extends mutable.AbstractSet[A] with mutable.SetOps[A, mutable.Set, mutable.Set[A]] {
+  case class JSetWrapper[A](underlying: ju.Set[A]) extends mutable.AbstractSet[A] with mutable.SetOps[A, mutable.Set, mutable.Set[A]] with Serializable {
 
     override def size = underlying.size
     override def isEmpty: Boolean = underlying.isEmpty
@@ -311,7 +311,7 @@ private[collection] trait Wrappers {
   @SerialVersionUID(3L)
   abstract class AbstractJMapWrapper[K, V]
     extends mutable.AbstractMap[K, V]
-      with JMapWrapperLike[K, V, mutable.Map, mutable.Map[K, V]]
+      with JMapWrapperLike[K, V, mutable.Map, mutable.Map[K, V]] with Serializable
 
   trait JMapWrapperLike[K, V, +CC[X, Y] <: mutable.MapOps[X, Y, CC, _], +C <: mutable.MapOps[K, V, CC, C]]
     extends mutable.MapOps[K, V, CC, C] {
@@ -358,7 +358,7 @@ private[collection] trait Wrappers {
     */
   @SerialVersionUID(3L)
   class JMapWrapper[K, V](val underlying : ju.Map[K, V])
-    extends AbstractJMapWrapper[K, V] {
+    extends AbstractJMapWrapper[K, V] with Serializable {
 
     override def isEmpty: Boolean = underlying.isEmpty
     override def knownSize: Int = if (underlying.isEmpty) 0 else super.knownSize
@@ -414,7 +414,7 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class DictionaryWrapper[K, V](underlying: mutable.Map[K, V]) extends ju.Dictionary[K, V] {
+  case class DictionaryWrapper[K, V](underlying: mutable.Map[K, V]) extends ju.Dictionary[K, V] with Serializable {
     def size: Int = underlying.size
     def isEmpty: Boolean = underlying.isEmpty
     def keys: ju.Enumeration[K] = asJavaEnumeration(underlying.keysIterator)
@@ -442,7 +442,7 @@ private[collection] trait Wrappers {
   }
 
   @SerialVersionUID(3L)
-  case class JDictionaryWrapper[K, V](underlying: ju.Dictionary[K, V]) extends mutable.AbstractMap[K, V] {
+  case class JDictionaryWrapper[K, V](underlying: ju.Dictionary[K, V]) extends mutable.AbstractMap[K, V] with Serializable {
     override def size: Int = underlying.size
     override def isEmpty: Boolean = underlying.isEmpty
     override def knownSize: Int = if (underlying.isEmpty) 0 else super.knownSize
@@ -466,7 +466,7 @@ private[collection] trait Wrappers {
 
   @SerialVersionUID(3L)
   case class JPropertiesWrapper(underlying: ju.Properties) extends mutable.AbstractMap[String, String]
-            with mutable.MapOps[String, String, mutable.Map, mutable.Map[String, String]] {
+            with mutable.MapOps[String, String, mutable.Map, mutable.Map[String, String]] with Serializable {
 
     override def size = underlying.size
     override def isEmpty: Boolean = underlying.isEmpty

src/library/scala/collection/generic/DefaultSerializationProxy.scala

@@ -67,3 +67,21 @@ final class DefaultSerializationProxy[A](factory: Factory[A, Any], @transient pr
 
 @SerialVersionUID(3L)
 private[collection] case object SerializeEnd
+
+/** Mix-in trait to enable DefaultSerializationProxy for the standard collection types. Depending on the type
+  * it is mixed into, it will dynamically choose `iterableFactory`, `mapFactory`, `sortedIterableFactory` or
+  * `sortedMapFactory` for deserialization into the respective `CC` type. Override `writeReplace` or implement
+  * 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[_] =>
+  protected[this] def writeReplace(): AnyRef = {
+    val f: Factory[Any, Any] = this match {
+      case it: scala.collection.SortedMap[_, _] => it.sortedMapFactory.sortedMapFactory[Any, Any](it.ordering.asInstanceOf[Ordering[Any]]).asInstanceOf[Factory[Any, Any]]
+      case it: scala.collection.Map[_, _] => it.mapFactory.mapFactory[Any, Any].asInstanceOf[Factory[Any, Any]]
+      case it: scala.collection.SortedSet[_] => it.sortedIterableFactory.evidenceIterableFactory[Any](it.ordering.asInstanceOf[Ordering[Any]])
+      case it => it.iterableFactory.iterableFactory
+    }
+    new DefaultSerializationProxy(f, this)
+  }
+}

src/library/scala/collection/immutable/ArraySeq.scala

@@ -37,7 +37,8 @@ sealed abstract class ArraySeq[+A]
   extends AbstractSeq[A]
     with IndexedSeq[A]
     with IndexedSeqOps[A, ArraySeq, ArraySeq[A]]
-    with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]] {
+    with StrictOptimizedSeqOps[A, ArraySeq, ArraySeq[A]]
+    with Serializable {
 
   /** The tag of the element type. This does not have to be equal to the element type of this ArraySeq. A primitive
     * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype
@@ -157,8 +158,6 @@ sealed abstract class ArraySeq[+A]
     copied
   }
 
-  override protected[this] def writeReplace(): AnyRef = this
-
   override protected final def applyPreferredMaxLength: Int = Int.MaxValue
 
   override def sorted[B >: A](implicit ord: Ordering[B]): ArraySeq[A] =

src/library/scala/collection/immutable/BitSet.scala

@@ -32,7 +32,8 @@ sealed abstract class BitSet
     with SortedSetOps[Int, SortedSet, BitSet]
     with StrictOptimizedSortedSetOps[Int, SortedSet, BitSet]
     with collection.BitSet
-    with collection.BitSetOps[BitSet] {
+    with collection.BitSetOps[BitSet]
+    with Serializable {
 
   override def unsorted: Set[Int] = this
 
@@ -77,7 +78,7 @@ sealed abstract class BitSet
   override def zip[B](that: scala.IterableOnce[B])(implicit @implicitNotFound(collection.BitSet.zipOrdMsg) ev: Ordering[(Int, B)]): SortedSet[(Int, B)] =
     super.zip(that)
 
-  override protected[this] def writeReplace(): AnyRef = new BitSet.SerializationProxy(this)
+  protected[this] def writeReplace(): AnyRef = new BitSet.SerializationProxy(this)
 }
 
 /**

src/library/scala/collection/immutable/HashMap.scala

@@ -18,6 +18,7 @@ import java.lang.System.arraycopy
 
 import scala.annotation.unchecked.{uncheckedVariance => uV}
 import scala.collection.Hashing.improve
+import scala.collection.generic.DefaultSerializable
 import scala.collection.mutable.{Builder, ReusableBuilder}
 import scala.collection.{Iterator, MapFactory, StrictOptimizedIterableOps, mutable}
 import scala.util.hashing.MurmurHash3
@@ -37,7 +38,8 @@ import scala.runtime.Statics.releaseFence
 
 final class HashMap[K, +V] private[immutable] (private[immutable] val rootNode: MapNode[K, V])
   extends AbstractMap[K, V]
-    with StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]] {
+    with StrictOptimizedMapOps[K, V, HashMap, HashMap[K, V]]
+    with DefaultSerializable {
 
   def this() = this(MapNode.empty)