Mitigate #9596 for SJS: Make objects serializable only in the JVM back-end.

Author: sjrd

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -238,11 +238,30 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
       val ps = claszSymbol.info.parents
       val superClass: String = if (ps.isEmpty) ObjectReference.internalName else internalName(ps.head.widenDealias.typeSymbol)
-      val interfaceNames = classBTypeFromSymbol(claszSymbol).info.interfaces map {
+      val interfaceNames0 = classBTypeFromSymbol(claszSymbol).info.interfaces map {
         case classBType =>
           if (classBType.isNestedClass) { innerClassBufferASM += classBType }
           classBType.internalName
       }
+      /* To avoid deadlocks when combining objects, lambdas and multi-threading,
+       * lambdas in objects are compiled to instance methods of the module class
+       * instead of static methods (see tests/run/deadlock.scala and
+       * https://github.com/scala/scala-dev/issues/195 for details).
+       * This has worked well for us so far but this is problematic for
+       * serialization: serializing a lambda requires serializing all the values
+       * it captures, if this lambda is in an object, this means serializing the
+       * enclosing object, which fails if the object does not extend
+       * Serializable.
+       * Because serializing objects is basically free since #5775, it seems like
+       * the simplest solution is to simply make all objects Serializable, this
+       * certainly seems preferable to deadlocks.
+       * This cannot be done earlier because Scala.js would not like it (#9596).
+       */
+      val interfaceNames =
+        if (claszSymbol.is(ModuleClass) && !interfaceNames0.contains("java/io/Serializable"))
+          interfaceNames0 :+ "java/io/Serializable"
+        else
+          interfaceNames0
 
       val flags = javaFlags(claszSymbol)
 

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -614,8 +614,6 @@ object desugar {
       parents1 = enumClassTypeRef :: Nil
     if (isCaseClass | isCaseObject)
       parents1 = parents1 :+ scalaDot(str.Product.toTypeName) :+ scalaDot(nme.Serializable.toTypeName)
-    else if (isObject)
-      parents1 = parents1 :+ scalaDot(nme.Serializable.toTypeName)
     if (isEnum)
       parents1 = parents1 :+ ref(defn.EnumClass.typeRef)
 

compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala

@@ -358,15 +358,18 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     newSymbol(clazz, nme.writeReplace, Method | Private | Synthetic,
         MethodType(Nil, defn.AnyRefType), coord = clazz.coord).entered.asTerm
 
-  /** If this is a serializable static object `Foo`, add the method:
+  /** If this is a static object `Foo`, add the method:
    *
    *      private def writeReplace(): AnyRef =
    *        new scala.runtime.ModuleSerializationProxy(classOf[Foo.type])
    *
    *  unless an implementation already exists, otherwise do nothing.
+   *
+   *  All static objects receive the `Serializable` flag in the back-end, so
+   *  we do that even for objects that are not serializable at this phase.
    */
   def serializableObjectMethod(clazz: ClassSymbol)(using Context): List[Tree] =
-    if clazz.is(Module) && clazz.isStatic && clazz.isSerializable && !hasWriteReplace(clazz) then
+    if clazz.is(Module) && clazz.isStatic && !hasWriteReplace(clazz) then
       List(
         DefDef(writeReplaceDef(clazz),
           _ => New(defn.ModuleSerializationProxyClass.typeRef,