WIP serialization

Author: retronym

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

@@ -1312,16 +1312,34 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         mt.toASMType
       }
 
+      val FLAG_SERIALIZABLE = 1
+      val FLAG_MARKERS = 2
+      val flags: Int = FLAG_SERIALIZABLE | FLAG_MARKERS
+      val ScalaSerializable = classBTypeFromSymbol(definitions.SerializableClass).toASMType
       bc.jmethod.visitInvokeDynamicInsn(methodName, desc, lambdaMetaFactoryBootstrapHandle,
           // boostrap args
-        applyN, targetHandle, constrainedType
+        applyN, targetHandle, constrainedType,
+        flags.asInstanceOf[AnyRef], 1.asInstanceOf[AnyRef], ScalaSerializable, 0.asInstanceOf[AnyRef]
       )
     }
   }
 
+  //   CallSite altMetafactory(MethodHandles.Lookup caller,
+  //  String invokedName,
+
+  //  MethodType invokedType,
+  //  MethodType samMethodType,
+  //  MethodHandle implMethod,
+  //  MethodType instantiatedMethodType,
+  //  int flags,
+  //  int markerInterfaceCount,  // IF flags has MARKERS set
+  //  Class... markerInterfaces, // IF flags has MARKERS set
+  //  int bridgeCount,           // IF flags has BRIDGES set
+  //  MethodType... bridges      // IF flags has BRIDGES set
+  //  )
   val lambdaMetaFactoryBootstrapHandle =
     new asm.Handle(asm.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;")
+      definitions.LambdaMetaFactory.fullName('/'), sn.AltMetafactory.toString,
+      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;")
 
 }

src/library/scala/runtime/LambdaDeserializer.scala

@@ -0,0 +1,47 @@
+package scala.runtime
+
+import java.lang.invoke._
+
+//
+// class C { def foo = { () => "" } }
+//
+// class C {
+//   def foo = { LMF(anonFun$1 };
+//   private def anonFun$1 = "";
+//   private <static> val lambdaDeserializer$1 = new LambdaDeserializer(MethodHandles.lookup))
+//   def $deserializeLambda$(serialized: SerializedLambda) = lambdaDeserializer$1.deserializeLambda(serialized) }
+// }
+//
+final class LambdaDeserializer(lookup: MethodHandles.Lookup) {
+  def deserializeLambda(serialized: SerializedLambda): AnyRef = {
+    val caller = lookup
+    //    serialized.getFunctionalInterfaceClass
+    val loader = lookup.lookupClass().getClassLoader
+    val funcInterfacesSignature = MethodType.fromMethodDescriptorString(serialized.getFunctionalInterfaceMethodSignature, loader)
+    val methodType = funcInterfacesSignature
+    val instantiated = MethodType.fromMethodDescriptorString(serialized.getInstantiatedMethodType, loader)
+//    val invokedType = MethodType.methodType(loader.loadClass(serialized.getFunctionalInterfaceClass.replaceAll("/", ".")))
+    val implMethodSig = MethodType.fromMethodDescriptorString(serialized.getImplMethodSignature, loader)
+    val implClass =loader.loadClass(serialized.getImplClass)
+
+    val from = implMethodSig.parameterCount() - funcInterfacesSignature.parameterCount()
+    val to = implMethodSig.parameterCount()
+    val invokedType = implMethodSig.dropParameterTypes(from, to).changeReturnType(loader.loadClass(serialized.getFunctionalInterfaceClass.replaceAll("/", ".")))
+
+
+    val implMethod: MethodHandle = {
+      serialized.getImplMethodKind match {
+        case MethodHandleInfo.REF_invokeStatic =>
+          caller.findStatic(implClass, serialized.getImplMethodName, implMethodSig)
+        case MethodHandleInfo.REF_invokeVirtual =>
+          caller.findVirtual(implClass, serialized.getImplMethodName, implMethodSig)
+      }
+    }
+    val site = LambdaMetafactory.metafactory(caller, serialized.getFunctionalInterfaceMethodName, invokedType, methodType, implMethod, methodType)
+    val factory = site.getTarget
+    val captures = (0 to serialized.getCapturedArgCount).map(serialized.getCapturedArg)
+    val r = factory.invokeWithArguments(captures: _*)
+    r
+  }
+}
+

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

@@ -514,6 +514,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ScalaSignatureAnnotation = requiredClass[scala.reflect.ScalaSignature]
     lazy val ScalaLongSignatureAnnotation = requiredClass[scala.reflect.ScalaLongSignature]
 
+    lazy val LambdaMetaFactory = getClassIfDefined("java.lang.invoke.LambdaMetafactory")
     lazy val MethodHandle = getClassIfDefined("java.lang.invoke.MethodHandle")
 
     // Option classes

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

@@ -1167,6 +1167,9 @@ trait StdNames {
     final val Invoke: TermName           = newTermName("invoke")
     final val InvokeExact: TermName      = newTermName("invokeExact")
 
+    final val Metafactory: TermName      = newTermName("metafactory")
+    final val AltMetafactory: TermName      = newTermName("altMetafactory")
+
     val Boxed = immutable.Map[TypeName, TypeName](
       tpnme.Boolean -> BoxedBoolean,
       tpnme.Byte    -> BoxedByte,