Add support for serializable lambdas

See scala/scala3#5836 for more information.

Author: smarter

src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala

@@ -12,7 +12,7 @@ package jvm
 import scala.annotation.switch
 
 import scala.tools.asm
-import scala.tools.asm.Label
+import scala.tools.asm.{Handle, Label, Opcodes}
 import scala.tools.nsc.backend.jvm.BCodeHelpers.InvokeStyle
 
 /*
@@ -27,6 +27,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
   import int._
   import bTypes._
   import coreBTypes._
+  import BCodeBodyBuilder._
 
   /*
    * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions.
@@ -1448,8 +1449,13 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     def genLoadTry(tree: Try): BType
 
     def genInvokeDynamicLambda(ctor: Symbol, lambdaTarget: Symbol, environmentSize: Int, functionalInterface: Symbol): BType = {
+      import java.lang.invoke.LambdaMetafactory.FLAG_SERIALIZABLE
+
       debuglog(s"Using invokedynamic rather than `new ${ctor.owner}`")
       val generatedType = classBTypeFromSymbol(functionalInterface)
+      // Lambdas should be serializable if they implement a SAM that extends Serializable or if they
+      // implement a scala.Function* class.
+      val isSerializable = functionalInterface.isSerializable || functionalInterface.isFunctionClass
       val isInterface = lambdaTarget.owner.isEmittedInterface
       val invokeStyle =
         if (lambdaTarget.isStaticMember) asm.Opcodes.H_INVOKESTATIC
@@ -1481,18 +1487,45 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         val mt = asmMethodType(abstractMethod)
         mt.toASMType
       }
-      bc.jmethod.visitInvokeDynamicInsn(methodName, desc, lambdaMetaFactoryBootstrapHandle,
-        // boostrap args
-        applyN, targetHandle, constrainedType
-      )
+      val bsmArgs0 = Seq(applyN, targetHandle, constrainedType)
+      val bsmArgs =
+        if (isSerializable)
+          bsmArgs0 +: Int.box(FLAG_SERIALIZABLE)
+        else
+          bsmArgs0
+
+      val metafactory =
+        if (isSerializable)
+          lambdaMetaFactoryAltMetafactoryHandle // altMetafactory needed to be able to pass the SERIALIZABLE flag
+        else
+          lambdaMetaFactoryMetafactoryHandle
+
+      bc.jmethod.visitInvokeDynamicInsn(methodName, desc, metafactory, bootstrapArgs: _*)
 
       generatedType
     }
   }
-  val lambdaMetaFactoryBootstrapHandle =
-    new asm.Handle(asm.Opcodes.H_INVOKESTATIC,
-      int.LambdaMetaFactory.javaBinaryName, int.MetafactoryName,
-      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
-      /* itf = */  int.LambdaMetaFactory.isEmittedInterface)
+}
 
+object BCodeBodyBuilder {
+  val lambdaMetaFactoryMetafactoryHandle = new Handle(
+    Opcodes.H_INVOKESTATIC,
+    "java/lang/invoke/LambdaMetafactory",
+    "metafactory",
+    "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
+    /* itf = */ false)
+
+  val lambdaMetaFactoryAltMetafactoryHandle = new Handle(
+    Opcodes.H_INVOKESTATIC,
+    "java/lang/invoke/LambdaMetafactory",
+    "altMetafactory",
+    "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;",
+    /* itf = */ false)
+
+  val lambdaDeserializeBootstrapHandle = new Handle(
+    Opcodes.H_INVOKESTATIC,
+    "scala/runtime/LambdaDeserialize",
+    "bootstrap",
+    "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;[Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/CallSite;",
+    /* itf = */ false)
 }

src/compiler/scala/tools/nsc/backend/jvm/BackendInterface.scala

@@ -511,6 +511,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def isJavaEntryPoint: Boolean
     def isJavaDefaultMethod: Boolean
     def isClassConstructor: Boolean
+    def isSerializable: Boolean
 
     /**
      * True for module classes of modules that are top-level or owned only by objects. Module classes
@@ -585,6 +586,11 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
 
 
     def samMethod(): Symbol
+
+    /** Is this the symbol of one of the `scala.Function*` class ?
+     *  Note that this will return false for subclasses of these classes.
+     */
+    def isFunctionClass: Boolean
   }
 
   abstract class TypeHelper {
@@ -723,7 +729,6 @@ abstract class BackendInterfaceDefinitions { self: BackendInterface =>
 
   val ScalaATTRName: String = "Scala"
   val ScalaSignatureATTRName: String = "ScalaSig"
-  val MetafactoryName: String = "metafactory"
 
   def doLabmdasFollowJVMMetafactoryOrder: Boolean = true
 
@@ -745,6 +750,8 @@ abstract class BackendInterfaceDefinitions { self: BackendInterface =>
   val JavaSerializableClass: Symbol = requiredClass[java.io.Serializable]
   val SerializableClass: Symbol = requiredClass[scala.Serializable]
   val ClassCastExceptionClass: Symbol = requiredClass[java.lang.ClassCastException]
+  val IllegalArgExceptionClass: Symbol = requiredClass[java.lang.IllegalArgumentException]
+  val SerializedLambdaClass: Symbol = requiredClass[java.lang.invoke.SerializedLambda]
 
   val ClassfileAnnotationClass: Symbol = requiredClass[scala.annotation.ClassfileAnnotation]
   val BoxedNumberClass: Symbol = requiredClass[java.lang.Number]

src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala

@@ -119,6 +119,8 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: BackendInterface]](val bTypes: B
   lazy val jioSerializableReference    : ClassBType = classBTypeFromSymbol(JavaSerializableClass)     // java/io/Serializable
   lazy val scalaSerializableReference  : ClassBType = classBTypeFromSymbol(SerializableClass)         // scala/Serializable
   lazy val classCastExceptionReference : ClassBType = classBTypeFromSymbol(ClassCastExceptionClass)   // java/lang/ClassCastException
+  lazy val jlIllegalArgExceptionRef: ClassBType = classBTypeFromSymbol(IllegalArgExceptionClass)
+  lazy val jliSerializedLambdaRef: ClassBType = classBTypeFromSymbol(SerializedLambdaClass)
 
   lazy val srBooleanRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BooleanRef])
   lazy val srByteRef    : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.ByteRef])
@@ -249,6 +251,8 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: BackendInterface]](va
   def jioSerializableReference    : ClassBType = _coreBTypes.jioSerializableReference
   def scalaSerializableReference  : ClassBType = _coreBTypes.scalaSerializableReference
   def classCastExceptionReference : ClassBType = _coreBTypes.classCastExceptionReference
+  def jlIllegalArgExceptionRef    : ClassBType = _coreBTypes.jlIllegalArgExceptionRef
+  def jliSerializedLambdaRef      : ClassBType = _coreBTypes.jliSerializedLambdaRef
 
   def srBooleanRef : ClassBType = _coreBTypes.srBooleanRef
   def srByteRef    : ClassBType = _coreBTypes.srByteRef