Use proxy-based serialization for modules

This avoids serializing any state of serializable singletons which
would be discarded anyway after deserializing (SI-10412).

Use ClassValue to cache instances, which is significantly faster for
subsequent deserialization of a given module. ClassValue entries only
weakly reference the key and value so the class can be unloaded.

Wrap use of reflection in AccessControler to play nicely under
SecurityManager. A security manager will only walk up the stack
to this point to check permissions, so if users grant scala-library
permissions in the policy, the call will be allowed regardless of
the code higher in the stack that has triggered deserialization.

Author: szeiger

src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala

@@ -36,7 +36,7 @@ import symtab.Flags._
  *    def toString(): String
  *
  *  Special handling:
- *    protected def readResolve(): AnyRef
+ *    protected def writeReplace(): AnyRef
  */
 trait SyntheticMethods extends ast.TreeDSL {
   self: Analyzer =>
@@ -331,16 +331,17 @@ trait SyntheticMethods extends ast.TreeDSL {
       // Object_equals   -> (() => createMethod(Object_equals)(m => This(clazz) ANY_EQ Ident(m.firstParam)))
     )
 
-    /* If you serialize a singleton and then deserialize it twice,
-     * you will have two instances of your singleton unless you implement
-     * readResolve.  Here it is implemented for all objects which have
-     * no implementation and which are marked serializable (which is true
-     * for all case objects.)
+    /* If you serialize a singleton you will get an additional 
+     * instance of the singleton, unless you implement 
+     * special serialization logic.  Here we use a serialization proxy that prevents 
+     * serialization of state and will, on deserialization by replaced by the object
+     * via use of readResolve. This is done for all top level objects which extend
+     * `java.io.Serializable` (such as case objects)
      */
-    def needsReadResolve = (
+    def needsModuleSerializationProxy = (
          clazz.isModuleClass
       && clazz.isSerializable
-      && !hasConcreteImpl(nme.readResolve)
+      && !hasConcreteImpl(nme.writeReplace)
       && clazz.isStatic
     )
 
@@ -374,13 +375,14 @@ trait SyntheticMethods extends ast.TreeDSL {
         for ((m, impl) <- methods ; if shouldGenerate(m)) yield impl()
       }
       def extras = {
-        if (needsReadResolve) {
+        if (needsModuleSerializationProxy) {
           // Aha, I finally decoded the original comment.
           // This method should be generated as private, but apparently if it is, then
           // it is name mangled afterward.  (Wonder why that is.) So it's only protected.
-          // For sure special methods like "readResolve" should not be mangled.
-          List(createMethod(nme.readResolve, Nil, ObjectTpe)(m => {
-            m setFlag PRIVATE; REF(clazz.sourceModule)
+          // For sure special methods like "writeReplace" should not be mangled.
+          List(createMethod(nme.writeReplace, Nil, ObjectTpe)(m => {
+            m setFlag PRIVATE
+            New(ModuleSerializationProxyClass, gen.mkClassOf(clazz.typeOfThis))
           }))
         }
         else Nil

src/library/scala/collection/Iterator.scala

@@ -1190,11 +1190,6 @@ object Iterator extends IterableFactory[Iterator] {
       } else Iterator.empty.next()
     }
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 /** Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses. */

src/library/scala/collection/View.scala

@@ -441,11 +441,6 @@ object View extends IterableFactory[View] {
     }
     override def isEmpty: Boolean = underlying.isEmpty && len <= 0
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 /** Explicit instantiation of the `View` trait to reduce class file size in subclasses. */

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

@@ -1019,11 +1019,6 @@ object TrieMap extends MapFactory[TrieMap] {
   class MangledHashing[K] extends Hashing[K] {
     def hash(k: K)= scala.util.hashing.byteswap32(k.##)
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 

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

@@ -423,9 +423,4 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
       case _ => super.equals(that)
     }
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

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

@@ -155,9 +155,4 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] {
   private final class SerializationProxy(coll: BitSet) extends scala.collection.BitSet.SerializationProxy(coll) {
     protected[this] def readResolve(): Any = BitSet.fromBitMaskNoCopy(elems)
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

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

@@ -1328,11 +1328,6 @@ object HashMap extends MapFactory[HashMap] {
     }
 
   def newBuilder[K, V]: Builder[(K, V), HashMap[K, V]] = new HashMapBuilder[K, V]
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 

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

@@ -789,11 +789,6 @@ object HashSet extends IterableFactory[HashSet] {
     }
 
   def newBuilder[A]: Builder[A, HashSet[A]] = new HashSetBuilder
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 private[collection] final class HashSetBuilder[A] extends Builder[A, HashSet[A]] {

src/library/scala/collection/immutable/IntMap.scala

@@ -104,11 +104,6 @@ object IntMap {
 
   implicit def iterableFactory[V]: Factory[(Int, V), IntMap[V]] = toFactory(this)
   implicit def buildFromIntMap[V]: BuildFrom[IntMap[_], (Int, V), IntMap[V]] = toBuildFrom(this)
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 // Iterator over a non-empty IntMap.

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

@@ -869,11 +869,6 @@ object LazyList extends SeqFactory[LazyList] {
 
   def newBuilder[A]: Builder[A, LazyList[A]] = ArrayBuffer.newBuilder[A].mapResult(array => from(array))
 
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
-
   /** This serialization proxy is used for LazyLists which start with a sequence of evaluated cons cells.
     * The forced sequence is serialized in a compact, sequential format, followed by the unevaluated tail, which uses
     * standard Java serialization to store the complete structure of unevaluated thunks. This allows the serialization

src/library/scala/collection/immutable/List.scala

@@ -618,9 +618,4 @@ object List extends StrictOptimizedSeqFactory[List] {
   def empty[A]: List[A] = Nil
 
   private[collection] val partialNotApplied = new Function1[Any, Any] { def apply(x: Any): Any = this }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/immutable/ListMap.scala

@@ -175,9 +175,4 @@ object ListMap extends MapFactory[ListMap] {
     new ImmutableBuilder[(K, V), ListMap[K, V]](empty) {
       def addOne(elem: (K, V)): this.type = { elems = elems + elem; this }
     }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

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

@@ -138,9 +138,4 @@ object ListSet extends IterableFactory[ListSet] {
     new ImmutableBuilder[A, ListSet[A]](empty) {
       def addOne(elem: A): this.type = { elems = elems + elem; this }
     }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/immutable/LongMap.scala

@@ -101,11 +101,6 @@ object LongMap {
 
   implicit def iterableFactory[V]: Factory[(Long, V), LongMap[V]] = toFactory(this)
   implicit def buildFromLongMap[V]: BuildFrom[LongMap[_], (Long, V), LongMap[V]] = toBuildFrom(this)
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 // Iterator over a non-empty LongMap.

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

@@ -410,11 +410,6 @@ object Map extends MapFactory[Map] {
     private[immutable] def buildTo[V1 >: V](builder: HashMapBuilder[K, V1]): builder.type =
       builder.addOne(key1, value1).addOne(key2, value2).addOne(key3, value3).addOne(key4, value4)
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 /** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */

src/library/scala/collection/immutable/Queue.scala

@@ -189,9 +189,4 @@ object Queue extends StrictOptimizedSeqFactory[Queue] {
   override def apply[A](xs: A*): Queue[A] = new Queue[A](Nil, xs.toList)
 
   private object EmptyQueue extends Queue[Nothing](Nil, Nil) { }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/immutable/SeqMap.scala

@@ -203,10 +203,4 @@ object SeqMap extends MapFactory[SeqMap] {
       f((key1, value1)); f((key2, value2)); f((key3, value3)); f((key4, value4))
     }
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
-
 }

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

@@ -249,11 +249,6 @@ object Set extends IterableFactory[Set] {
     private[immutable] def buildTo(builder: Builder[A, Set[A]]): builder.type =
       builder.addOne(elem1).addOne(elem2).addOne(elem3).addOne(elem4)
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 /** Explicit instantiation of the `Set` trait to reduce class file size in subclasses. */

src/library/scala/collection/immutable/Stream.scala

@@ -451,11 +451,6 @@ object Stream extends SeqFactory[Stream] {
 
   def empty[A]: Stream[A] = Empty
 
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
-
   override def newBuilder[A]: mutable.Builder[A, Stream[A]] = ArrayBuffer.newBuilder[A].mapResult(array => from(array))
 
   private[immutable] def withFilter[A](l: Stream[A] @uncheckedVariance, p: A => Boolean): collection.WithFilter[A, Stream] =

src/library/scala/collection/immutable/Vector.scala

@@ -51,11 +51,6 @@ object Vector extends StrictOptimizedSeqFactory[Vector] {
   // Constants governing concat strategy for performance
   private final val Log2ConcatFaster = 5
   private final val TinyAppendFaster = 2
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
 
 // in principle, most members should be private. however, access privileges must

src/library/scala/collection/mutable/AnyRefMap.scala

@@ -565,9 +565,4 @@ object AnyRefMap {
 
   implicit def iterableFactory[K <: AnyRef, V]: Factory[(K, V), AnyRefMap[K, V]] = toFactory[K, V](this)
   implicit def buildFromAnyRefMap[K <: AnyRef, V]: BuildFrom[AnyRefMap[_, _], (K, V), AnyRefMap[K, V]] = toBuildFrom(this)
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/mutable/ArrayDeque.scala

@@ -603,9 +603,4 @@ object ArrayDeque extends StrictOptimizedSeqFactory[ArrayDeque] {
     require(size >= 0, s"ArrayDeque too big - cannot allocate ArrayDeque of length $len")
     new Array[AnyRef](Math.max(size, DefaultInitialSize))
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/mutable/ArraySeq.scala

@@ -304,9 +304,4 @@ object ArraySeq extends StrictOptimizedClassTagSeqFactory[ArraySeq] { self =>
       case _ => super.equals(that)
     }
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/mutable/BitSet.scala

@@ -205,9 +205,4 @@ object BitSet extends SpecificIterableFactory[Int, BitSet] {
   private final class SerializationProxy(coll: BitSet) extends scala.collection.BitSet.SerializationProxy(coll) {
     protected[this] def readResolve(): Any = BitSet.fromBitMaskNoCopy(elems)
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/mutable/LongMap.scala

@@ -646,9 +646,4 @@ object LongMap {
 
   implicit def iterableFactory[V]: Factory[(Long, V), LongMap[V]] = toFactory(this)
   implicit def buildFromLongMap[V]: BuildFrom[LongMap[_], (Long, V), LongMap[V]] = toBuildFrom(this)
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/collection/mutable/UnrolledBuffer.scala

@@ -422,9 +422,4 @@ object UnrolledBuffer extends StrictOptimizedClassTagSeqFactory[UnrolledBuffer]
     override def toString: String =
       array.take(size).mkString("Unrolled@%08x".format(System.identityHashCode(this)) + "[" + size + "/" + array.length + "](", ", ", ")") + " -> " + (if (next ne null) next.toString else "")
   }
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
 }

src/library/scala/runtime/ModuleSerializationProxy.java

@@ -0,0 +1,51 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.runtime;
+
+import java.io.Serializable;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.HashSet;
+import java.util.Set;
+
+/** A serialization proxy for singleton objects */
+public final class ModuleSerializationProxy implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private final Class<?> moduleClass;
+    private static final ClassValue<Object> instances = new ClassValue<Object>() {
+        @Override
+        protected Object computeValue(Class<?> type) {
+            try {
+                return AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> type.getField("MODULE$").get(null));
+            } catch (PrivilegedActionException e) {
+                return rethrowRuntime(e.getCause());
+            }
+        }
+    };
+
+    private static Object rethrowRuntime(Throwable e) {
+        Throwable cause = e.getCause();
+        if (cause instanceof RuntimeException) throw (RuntimeException) cause;
+        else throw new RuntimeException(cause);
+    }
+
+    public ModuleSerializationProxy(Class<?> moduleClass) {
+        this.moduleClass = moduleClass;
+    }
+
+    @SuppressWarnings("unused")
+    private Object readResolve() {
+        return instances.get(moduleClass);
+    }
+}

src/reflect/scala/reflect/internal/Definitions.scala

@@ -582,6 +582,9 @@ trait Definitions extends api.StandardDefinitions {
     lazy val NoneModule: ModuleSymbol   = requiredModule[scala.None.type]
     lazy val SomeModule: ModuleSymbol   = requiredModule[scala.Some.type]
 
+    // Serialization
+    lazy val ModuleSerializationProxyClass: ClassSymbol = requiredClass[scala.runtime.ModuleSerializationProxy]
+
     def compilerTypeFromTag(tt: ApiUniverse # WeakTypeTag[_]): Type = tt.in(rootMirror).tpe
     def compilerSymbolFromTag(tt: ApiUniverse # WeakTypeTag[_]): Symbol = tt.in(rootMirror).tpe.typeSymbol
 

src/reflect/scala/reflect/internal/StdNames.scala

@@ -839,6 +839,7 @@ trait StdNames {
     val values : NameType              = "values"
     val wait_ : NameType               = "wait"
     val withFilter: NameType           = "withFilter"
+    val writeReplace: NameType         = "writeReplace"
     val xml: NameType                  = "xml"
     val zero: NameType                 = "zero"