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