Replace Cloneable/Serializable traits with type aliases

Fixes scala/bug#9080.

This commit is adapted from scala/scala#5288 and is thus:

Co-authored-by: Simon Ochsenreither <[email protected]>

Author: smarter

library/src/scala/Cloneable.scala

@@ -14,6 +14,9 @@ import scala.annotation.migration
  * @contentDiagram hideNodes "scala.Serializable"
  */
 package object scala {
+  type Cloneable    = java.lang.Cloneable
+  type Serializable = java.io.Serializable
+
   type Throwable = java.lang.Throwable
   type Exception = java.lang.Exception
   type Error     = java.lang.Error

library/src/scala/Serializable.scala

@@ -19,13 +19,12 @@ object LambdaDeserializer {
    * concurrent deserialization of the same lambda expression may spin up more than one class.
    *
    * Assumptions:
-   *  - No additional marker interfaces are required beyond `{java.io,scala.}Serializable`. These are
+   *  - No additional marker interfaces are required beyond `java.io.Serializable`. These are
    *    not stored in `SerializedLambda`, so we can't reconstitute them.
    *  - No additional bridge methods are passed to `altMetafactory`. Again, these are not stored.
    *
    * @param lookup      The factory for method handles. Must have access to the implementation method, the
-   *                    functional interface class, and `java.io.Serializable` or `scala.Serializable` as
-   *                    required.
+   *                    functional interface class, and `java.io.Serializable`.
    * @param cache       A cache used to avoid spinning up a class for each deserialization of a given lambda. May be `null`
    * @param serialized  The lambda to deserialize. Note that this is typically created by the `readResolve`
    *                    member of the anonymous class created by `LambdaMetaFactory`.
@@ -77,20 +76,15 @@ object LambdaDeserializer {
         throw new IllegalArgumentException("Illegal lambda deserialization")
       }
 
-      val flags: Int = LambdaMetafactory.FLAG_SERIALIZABLE | LambdaMetafactory.FLAG_MARKERS
-      val isScalaFunction = functionalInterfaceClass.getName.startsWith("scala.Function")
-      val markerInterface: Class[_] = loader.loadClass(if (isScalaFunction) ScalaSerializable else JavaIOSerializable)
+      val flags: Int = LambdaMetafactory.FLAG_SERIALIZABLE
 
       LambdaMetafactory.altMetafactory(
         lookup, getFunctionalInterfaceMethodName, invokedType,
 
         /* samMethodType          = */ funcInterfaceSignature,
         /* implMethod             = */ implMethod,
         /* instantiatedMethodType = */ instantiated,
-        /* flags                  = */ flags.asInstanceOf[AnyRef],
-        /* markerInterfaceCount   = */ 1.asInstanceOf[AnyRef],
-        /* markerInterfaces[0]    = */ markerInterface,
-        /* bridgeCount            = */ 0.asInstanceOf[AnyRef]
+        /* flags                  = */ flags.asInstanceOf[AnyRef]
       )
     }
 
@@ -111,8 +105,6 @@ object LambdaDeserializer {
     factory.invokeWithArguments(captures: _*)
   }
 
-  private[this] val ScalaSerializable = "scala.Serializable"
-
   private[this] val JavaIOSerializable = {
     // We could actually omit this marker interface as LambdaMetaFactory will add it if
     // the FLAG_SERIALIZABLE is set and of the provided markers extend it. But the code