JVM_IR serializable indy method references

2021-10-18 12:46:58 +03:00
parent eec16b83c6
commit 1dbbe22c8c
38 changed files with 1960 additions and 221 deletions
@@ -5,7 +5,7 @@

 // CHECK_BYTECODE_TEXT
 // JVM_IR_TEMPLATES
-// 0 java/lang/invoke/LambdaMetafactory
+// 2 java/lang/invoke/LambdaMetafactory

 // FILE: serializableSam1.kt
 import java.io.ByteArrayInputStream
@@ -5,7 +5,7 @@

 // CHECK_BYTECODE_TEXT
 // JVM_IR_TEMPLATES
-// 0 java/lang/invoke/LambdaMetafactory
+// 2 java/lang/invoke/LambdaMetafactory

 // FILE: serializableSam2.kt
 import java.io.ByteArrayInputStream
@@ -0,0 +1,62 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// We generate 1 clause in '$deserializeLambda' for each unique possible combination of deserialized lambda parameters
+// (that's all information stored during indy lambda serialization, anyway).
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 12 java/lang/invoke/LambdaMetafactory
+// 1 (LOOKUP|TABLE)SWITCH
+// 24 java/lang/String\.equals
+
+// FILE: multipleTopLevelFunRefs.kt
+import java.io.*
+
+fun plusK1(s: String) = s + "K"
+fun plusK2(s: String) = s + "K"
+fun plusK3(s: String) = s + "K"
+fun plusK4(s: String) = s + "K"
+
+fun box(): String {
+    val t1 = roundtrip(Sam(::plusK1)).get("O")
+    if (t1 != "OK") return "Failed: t1='$t1'"
+
+    val t1a = roundtrip(Sam(::plusK1)).get("O")
+    if (t1a != "OK") return "Failed: t1a='$t1a'"
+
+    val t1b = roundtrip(Sam(::plusK1)).get("O")
+    if (t1b != "OK") return "Failed: t1b='$t1b'"
+
+    val t2 = roundtrip(Sam(::plusK2)).get("O")
+    if (t2 != "OK") return "Failed: t2='$t2'"
+
+    val t2a = roundtrip(Sam(::plusK2)).get("O")
+    if (t2a != "OK") return "Failed: t2a='$t2a'"
+
+    val t3 = roundtrip(Sam(::plusK3)).get("O")
+    if (t3 != "OK") return "Failed: t3='$t3'"
+
+    val t4 = roundtrip(Sam(::plusK4)).get("O")
+    if (t4 != "OK") return "Failed: t4='$t4'"
+
+    val t4a = roundtrip(Sam(::plusK4)).get("O")
+    if (t4a != "OK") return "Failed: t4a='$t4a'"
+
+    return "OK"
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,47 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 4 java/lang/invoke/LambdaMetafactory
+
+// FILE: sameImplMethodDifferentInterfaces.kt
+import java.io.*
+
+fun plusK(s: String) = s + "K"
+
+fun box(): String {
+    val sam1 = roundtrip(Sam1(::plusK))
+    if (sam1 !is Sam1) return "Failed: $sam1 !is Sam1"
+    val t1 = sam1.get("O")
+    if (t1 != "OK") return "Failed: $t1='$t1'"
+
+    val sam2 = roundtrip(Sam2(::plusK))
+    if (sam2 !is Sam2) return "Failed: $sam2 !is Sam2"
+    val t2 = sam2.get("O")
+    if (t2 != "OK") return "Failed: $t2='$t2'"
+
+    return "OK"
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam1.java
+import java.io.*;
+
+public interface Sam1 extends Serializable {
+    String get(String s);
+}
+
+// FILE: Sam2.java
+import java.io.*;
+
+public interface Sam2 extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,33 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableBoundClassMemberFunRef.kt
+import java.io.*
+
+class C(val s: String) : Serializable {
+    fun plus(ss: String) = ss + s
+}
+
+fun box(): String {
+    return roundtrip(Sam(C("K")::plus))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,35 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableBoundInnerConstructorRef.kt
+import java.io.*
+
+class Outer(val s1: String) : Serializable {
+    inner class Inner (val s2: String) {
+        fun test() = s1 + s2
+    }
+}
+
+fun box(): String {
+    return roundtrip(Sam(Outer("O")::Inner))
+        .get("K").test()
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    Outer.Inner get(String s);
+}
@@ -0,0 +1,38 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableBoundInterfaceMemberFunRef.kt
+import java.io.*
+
+interface Plus {
+    fun plus(ss: String): String
+}
+
+class C(val s: String) : Plus, Serializable {
+    override fun plus(ss: String) = ss + s
+}
+
+fun box(): String {
+    val p: Plus = C("K")
+    return roundtrip(Sam(p::plus))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableBoundTopLevelExtensionFunRef.kt
+import java.io.*
+
+fun String.plusK(k: String) = this + k
+
+fun box(): String {
+    return roundtrip(Sam("O"::plusK))
+        .get("K")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableBoundTopLevelExtensionFunRefPrimitiveReceiver.kt
+import java.io.*
+
+fun Int.plusK(k: String) = this.toChar().toString() + k
+
+fun box(): String {
+    return roundtrip(Sam(('O'.toInt())::plusK))
+        .get("K")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,33 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableClassMemberFunRef.kt
+import java.io.*
+
+class C(val s: String) {
+    fun plus(ss: String) = ss + s
+}
+
+fun box(): String {
+    return roundtrip(Sam(C::plus))
+        .get(C("K"), "O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(C x, String s);
+}
@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableConstructorRef.kt
+import java.io.*
+
+class C(val t: String)
+
+fun box(): String {
+    return roundtrip(Sam(::C))
+        .get("OK").t
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    C get(String s);
+}
@@ -0,0 +1,39 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+// 2 A\.plus\(Ljava/lang/String;\)Ljava/lang/String;\,
+//  ^ check that we generate a reference to A::plus (same as javac)
+
+// FILE: serializableFakeOverrideFunRef.kt
+import java.io.*
+
+abstract class A(val s: String) {
+    fun plus(ss: String) = ss + s
+}
+
+abstract class B(s: String) : A(s)
+
+class C(s: String) : B(s)
+
+fun box(): String {
+    return roundtrip(Sam(C::plus))
+        .get(C("K"), "O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(C x, String s);
+}
@@ -0,0 +1,35 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableInnerConstructorRef.kt
+import java.io.*
+
+class Outer(val s1: String) {
+    inner class Inner (val s2: String) {
+        fun test() = s1 + s2
+    }
+}
+
+fun box(): String {
+    return roundtrip(Sam(Outer::Inner))
+        .get(Outer("O"), "K").test()
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    Outer.Inner get(Outer outer, String s);
+}
@@ -0,0 +1,37 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableInterfaceMemberFunRef.kt
+import java.io.*
+
+interface Plus {
+    fun plus(ss: String): String
+}
+
+class C(val s: String) : Plus {
+    override fun plus(ss: String) = ss + s
+}
+
+fun box(): String {
+    return roundtrip(Sam(Plus::plus))
+        .get(C("K"), "O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(Plus x, String s);
+}
@@ -0,0 +1,36 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableJavaStaticMethodRef.kt
+import java.io.*
+
+fun box(): String {
+    return roundtrip(Sam(J::plusK))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
+
+// FILE: J.java
+public class J {
+    public static String plusK(String s) {
+        return s + "K";
+    }
+}
@@ -0,0 +1,29 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambda.kt
+import java.io.*
+
+fun box(): String {
+    return roundtrip(Sam { s -> s + "K" })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaCapturingBoxedInlineClassAny.kt
+import java.io.*
+
+inline class IC(val x: Any) : Serializable
+
+fun box(): String {
+    val k: Any = IC("K")
+    return roundtrip(Sam { s -> s + (k as IC).x })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaCapturingInlineClassAny.kt
+import java.io.*
+
+inline class IC(val x: Any)
+
+fun box(): String {
+    val k = IC("K")
+    return roundtrip(Sam { s -> s + k.x })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaCapturingInlineClassInt.kt
+import java.io.*
+
+inline class IC(val x: Int)
+
+fun box(): String {
+    val k = IC('K'.toInt())
+    return roundtrip(Sam { s -> s + k.x.toChar().toString() })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaCapturingNullableInlineClassAny.kt
+import java.io.*
+
+inline class IC(val x: Any) : Serializable
+
+fun box(): String {
+    val k: IC? = IC("K")
+    return roundtrip(Sam { s -> s + k!!.x })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,26 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaToKotlinInterface.kt
+import java.io.*
+
+fun interface Sam : Serializable {
+    fun get(s: String): String
+}
+
+fun box(): String {
+    return roundtrip(Sam { s -> s + "K" })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
@@ -0,0 +1,30 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableLambdaWithCapture.kt
+import java.io.*
+
+fun box(): String {
+    val k = "K"
+    return roundtrip(Sam { s -> s + k })
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableTopLevelFunRef.kt
+import java.io.*
+
+fun plusK(s: String) = s + "K"
+
+fun box(): String {
+    return roundtrip(Sam(::plusK))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam extends Serializable {
+    String get(String s);
+}
@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableTopLevelFunRefAsGenericInterface.kt
+import java.io.*
+
+fun plusK(s: String) = s + "K"
+
+fun box(): String {
+    return roundtrip(Sam<String>(::plusK))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Sam.java
+import java.io.*;
+
+public interface Sam<T> extends Serializable {
+    String get(T s);
+}
@@ -0,0 +1,38 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// SAM_CONVERSIONS: INDY
+// FULL_JDK
+
+// CHECK_BYTECODE_TEXT
+// JVM_IR_TEMPLATES
+// 2 java/lang/invoke/LambdaMetafactory
+
+// FILE: serializableWithBridge.kt
+import java.io.*
+
+fun plusK(s: String) = s + "K"
+
+fun box(): String {
+    return roundtrip(Sam(::plusK))
+        .get("O")
+}
+
+fun <T> roundtrip(x: T): T {
+    val out1 = ByteArrayOutputStream()
+    ObjectOutputStream(out1).writeObject(x)
+    return ObjectInputStream(ByteArrayInputStream(out1.toByteArray())).readObject() as T
+}
+
+// FILE: Base1.java
+public interface Base1<T1> {
+    String get(T1 s);
+}
+
+// FILE: Base2.java
+public interface Base2<T2 extends CharSequence> {
+    String get(T2 s);
+}
+
+// FILE: Sam.java
+public interface Sam extends Base1<String>, Base2<String>, java.io.Serializable {
+}