Test data split between compiledJava tests and compiledKotlin tests

Basically, this commit splits test data from the from java-txt-kt to two pairs java-txt and kt-txt.
This commit leads to some duplication in test data.
This is temporary: in the platform types branch the test data for LoadJava tests will be changed dramatically, so duplication will go away

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt

@@ -0,0 +1,29 @@
+package test
+
+public trait PropagateTypeArgumentNullable {
+
+    public trait Super {
+        public fun outS(p: List<String?>)
+
+        public fun invOutS(p : MutableList<List<String?>>)
+
+        public fun outOutS(p : List<List<String?>>)
+
+        public fun outR() : List<String?>
+        public fun invR() : MutableList<String?>
+        public fun invOutR() : MutableList<List<String?>>
+
+    }
+
+    public trait Sub: Super {
+        override fun outS(p: List<String?>)
+
+        override fun invOutS(p : MutableList<List<String?>>)
+
+        override fun outOutS(p : List<List<String?>>)
+
+        override fun outR() : List<String?>
+        override fun invR() : MutableList<String?>
+        override fun invOutR() : MutableList<List<String?>>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt

@@ -0,0 +1,22 @@
+package test
+
+public trait PropagateTypeArgumentNullable {
+
+    public trait Sub : test.PropagateTypeArgumentNullable.Super {
+        public abstract override /*1*/ fun invOutR(): kotlin.MutableList<kotlin.List<kotlin.String?>>
+        public abstract override /*1*/ fun invOutS(/*0*/ p: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract override /*1*/ fun invR(): kotlin.MutableList<kotlin.String?>
+        public abstract override /*1*/ fun outOutS(/*0*/ p: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract override /*1*/ fun outR(): kotlin.List<kotlin.String?>
+        public abstract override /*1*/ fun outS(/*0*/ p: kotlin.List<kotlin.String?>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun invOutR(): kotlin.MutableList<kotlin.List<kotlin.String?>>
+        public abstract fun invOutS(/*0*/ p: kotlin.MutableList<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract fun invR(): kotlin.MutableList<kotlin.String?>
+        public abstract fun outOutS(/*0*/ p: kotlin.List<kotlin.List<kotlin.String?>>): kotlin.Unit
+        public abstract fun outR(): kotlin.List<kotlin.String?>
+        public abstract fun outS(/*0*/ p: kotlin.List<kotlin.String?>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait ChangeProjectionKind1 {
+
+    public trait Super {
+        public fun foo(p: MutableList<in String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: MutableList<in String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait ChangeProjectionKind1 {
+
+    public trait Sub : test.ChangeProjectionKind1.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait ChangeProjectionKind2 {
+
+    public trait Super {
+        public fun foo(p: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: MutableList<String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait ChangeProjectionKind2 {
+
+    public trait Sub : test.ChangeProjectionKind2.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt

@@ -0,0 +1,18 @@
+package test
+
+public trait DeeplySubstitutedClassParameter {
+
+    public trait Super<T> {
+        public fun foo(t: T)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Middle<E>: Super<E> {
+        override fun foo(t: E)
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(t: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait DeeplySubstitutedClassParameter {
+
+    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: E): kotlin.Unit
+    }
+
+    public trait Sub : test.DeeplySubstitutedClassParameter.Middle<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt

@@ -0,0 +1,17 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2 {
+
+    public trait Super<T> {
+        public fun foo(t: T)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Middle<E>: Super<E> {
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(t: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2 {
+
+    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter2.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
+    }
+
+    public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritMutability.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritMutability {
+
+    public trait Super {
+        public fun foo(p: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: MutableList<String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritMutability.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritMutability {
+
+    public trait Sub : test.InheritMutability.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVararg.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVararg {
+
+    public trait Super {
+        public fun foo(p0: Array<out String>?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out String>?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVararg.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVararg {
+
+    public trait Sub : test.InheritNotVararg.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<out kotlin.String>?): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.Array<out kotlin.String>?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargInteger {
+
+    public trait Super {
+        public fun foo(p0: Array<out Int>?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out Int>?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargInteger {
+
+    public trait Sub : test.InheritNotVarargInteger.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.Array<out kotlin.Int>?): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.Array<out kotlin.Int>?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargNotNull {
+
+    public trait Super {
+        public fun foo(p: Array<out String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: Array<out String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargNotNull {
+
+    public trait Sub : test.InheritNotVarargNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.Array<out kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.Array<out kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargPrimitive {
+
+    public trait Super {
+        public fun foo(p0: IntArray?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: IntArray?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNotVarargPrimitive {
+
+    public trait Sub : test.InheritNotVarargPrimitive.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.IntArray?): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.IntArray?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNullability.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullability {
+
+    public trait Super {
+        public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNullability.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullability {
+
+    public trait Sub : test.InheritNullability.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritProjectionKind.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritProjectionKind {
+
+    public trait Super {
+        public fun foo(p: MutableList<in String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: MutableList<in String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritProjectionKind.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritProjectionKind {
+
+    public trait Sub : test.InheritProjectionKind.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<in kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritReadOnliness.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnliness {
+
+    public trait Super {
+        public fun foo(p: List<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: List<String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritReadOnliness.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnliness {
+
+    public trait Sub : test.InheritReadOnliness.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVararg.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVararg {
+
+    public trait Super {
+        public fun foo(vararg p0: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: String?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVararg.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVararg {
+
+    public trait Sub : test.InheritVararg.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.String? /*kotlin.Array<kotlin.String?>*/): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ vararg p0: kotlin.String? /*kotlin.Array<kotlin.String?>*/): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargInteger {
+
+    public trait Super {
+        public fun foo(vararg p0: Int?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargInteger {
+
+    public trait Sub : test.InheritVarargInteger.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.Int? /*kotlin.Array<kotlin.Int?>*/): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ vararg p0: kotlin.Int? /*kotlin.Array<kotlin.Int?>*/): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargNotNull {
+
+    public trait Super {
+        public fun foo(vararg p: String)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargNotNull {
+
+    public trait Sub : test.InheritVarargNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ vararg p: kotlin.String /*kotlin.Array<kotlin.String>*/): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargPrimitive {
+
+    public trait Super {
+        public fun foo(vararg p0: Int)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritVarargPrimitive {
+
+    public trait Sub : test.InheritVarargPrimitive.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/Kt3302.kt

@@ -0,0 +1,20 @@
+package test
+
+// See SubclassFromGenericAndNot, as well
+public trait Kt3302 {
+    public trait BSONObject  {
+        public fun put(p0: String, p1: Any): Any?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait LinkedHashMap<K, V>  {
+        public fun put(key: K, value: V): V?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait BasicBSONObject : LinkedHashMap<String, Any>, BSONObject {
+        override fun put(key: String, value: Any): Any?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/Kt3302.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait Kt3302 {
+
+    public trait BSONObject {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun put(/*0*/ p0: kotlin.String, /*1*/ p1: kotlin.Any): kotlin.Any?
+    }
+
+    public trait BasicBSONObject : test.Kt3302.LinkedHashMap<kotlin.String, kotlin.Any>, test.Kt3302.BSONObject {
+        public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*2*/ fun put(/*0*/ key: kotlin.String, /*1*/ value: kotlin.Any): kotlin.Any?
+    }
+
+    public trait LinkedHashMap</*0*/ K, /*1*/ V> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun put(/*0*/ key: K, /*1*/ value: V): V?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait MutableToReadOnly {
+
+    public trait Super {
+        public fun foo(p: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: MutableList<String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait MutableToReadOnly {
+
+    public trait Sub : test.MutableToReadOnly.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.MutableList<kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NotNullToNullable.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait NotNullToNullable {
+
+    public trait Super {
+        public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NotNullToNullable.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait NotNullToNullable {
+
+    public trait Sub : test.NotNullToNullable.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNull.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait NullableToNotNull {
+
+    public trait Super {
+        public fun foo(p0: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNull.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait NullableToNotNull {
+
+    public trait Sub : test.NullableToNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: kotlin.String?): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.String?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait NullableToNotNullKotlinSignature {
+
+    public trait Super {
+        public fun foo(p: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: String?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait NullableToNotNullKotlinSignature {
+
+    public trait Sub : test.NullableToNotNullKotlinSignature.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.String?): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.String?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait OverrideWithErasedParameter {
+
+    public trait Super<T> {
+        public fun foo(p0: T?)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub<T>: Super<T> {
+        override fun foo(p0: T?)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait OverrideWithErasedParameter {
+
+    public trait Sub</*0*/ T> : test.OverrideWithErasedParameter.Super<T> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p0: T?): kotlin.Unit
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: T?): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait ReadOnlyToMutable {
+
+    public trait Super {
+        public fun foo(p: List<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(p: List<String>)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait ReadOnlyToMutable {
+
+    public trait Sub : test.ReadOnlyToMutable.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p: kotlin.List<kotlin.String>): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt

@@ -0,0 +1,21 @@
+package test
+
+// Extracted from KT-3302, see Kt3302 test, as well
+public trait SubclassFromGenericAndNot {
+
+    public trait NonGeneric  {
+        public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Generic<T>  {
+        public fun foo(key: T)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub : NonGeneric, Generic<String> {
+        override fun foo(key: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait SubclassFromGenericAndNot {
+
+    public trait Generic</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ key: T): kotlin.Unit
+    }
+
+    public trait NonGeneric {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ p0: kotlin.String): kotlin.Unit
+    }
+
+    public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<kotlin.String> {
+        public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ key: kotlin.String): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait SubstitutedClassParameter {
+
+    public trait Super<T> {
+        public fun foo(t: T)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super<String> {
+        override fun foo(t: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait SubstitutedClassParameter {
+
+    public trait Sub : test.SubstitutedClassParameter.Super<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt

@@ -0,0 +1,20 @@
+package test
+
+public trait SubstitutedClassParameters {
+
+    public trait Super1<T> {
+        public fun foo(t: T)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Super2<E> {
+        public fun foo(t: E)
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super1<String>, Super2<String> {
+        override fun foo(t: String)
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait SubstitutedClassParameters {
+
+    public trait Sub : test.SubstitutedClassParameters.Super1<kotlin.String>, test.SubstitutedClassParameters.Super2<kotlin.String> {
+        public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*2*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    }
+
+    public trait Super1</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ t: T): kotlin.Unit
+    }
+
+    public trait Super2</*0*/ E> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(/*0*/ t: E): kotlin.Unit
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNotNullJavaSubtype  {
+
+    public trait Super {
+        public fun foo(): CharSequence?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNotNullJavaSubtype {
+
+    public trait Sub : test.AddNotNullJavaSubtype.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNotNullSameJavaType {
+
+    public trait Super {
+        public fun foo(): CharSequence?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNotNullSameJavaType {
+
+    public trait Sub : test.AddNotNullSameJavaType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.CharSequence
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilityJavaSubtype {
+
+    public trait Super {
+        public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilityJavaSubtype {
+
+    public trait Sub : test.AddNullabilityJavaSubtype.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameGenericType1 {
+
+    public trait Super {
+        public fun foo(): MutableList<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameGenericType1 {
+
+    public trait Sub : test.AddNullabilitySameGenericType1.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableList<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameGenericType2 {
+
+    public trait Super {
+        public fun foo(): MutableList<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameGenericType2 {
+
+    public trait Sub : test.AddNullabilitySameGenericType2.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableList<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameJavaType {
+
+    public trait Super {
+        public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait AddNullabilitySameJavaType {
+
+    public trait Sub : test.AddNullabilitySameJavaType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.CharSequence
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait CantMakeImmutableInSubclass {
+
+    public trait Super {
+        public fun foo(): MutableCollection<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait CantMakeImmutableInSubclass {
+
+    public trait Sub : test.CantMakeImmutableInSubclass.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableCollection<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt

@@ -0,0 +1,18 @@
+package test
+
+public trait DeeplySubstitutedClassParameter {
+
+    public trait Super<T> {
+        public fun foo(): T
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Middle<E>: Super<E> {
+        override fun foo(): E
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait DeeplySubstitutedClassParameter {
+
+    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): E
+    }
+
+    public trait Sub : test.DeeplySubstitutedClassParameter.Middle<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): T
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt

@@ -0,0 +1,17 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2 {
+
+    public trait Super<T> {
+        public fun foo(): T
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Middle<E>: Super<E> {
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2 {
+
+    public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter2.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun foo(): E
+    }
+
+    public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): T
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt

@@ -0,0 +1,16 @@
+package test
+
+public trait HalfSubstitutedTypeParameters {
+
+    public trait TrickyList<X, E>: MutableList<E> {}
+
+    public trait Super {
+        public fun foo(): MutableList<String?>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): TrickyList<Int, String?>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt

@@ -0,0 +1,38 @@
+package test
+
+public trait HalfSubstitutedTypeParameters {
+
+    public trait Sub : test.HalfSubstitutedTypeParameters.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): test.HalfSubstitutedTypeParameters.TrickyList<kotlin.Int, kotlin.String?>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableList<kotlin.String?>
+    }
+
+    public trait TrickyList</*0*/ X, /*1*/ E> : kotlin.MutableList<E> {
+        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ e: E): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: E): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<E>): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ c: kotlin.Collection<E>): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
+        public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): E
+        public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+        public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.MutableIterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: kotlin.Any?): kotlin.Int
+        public abstract override /*1*/ /*fake_override*/ fun listIterator(): kotlin.MutableListIterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.MutableListIterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ index: kotlin.Int): E
+        public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: E): E
+        public abstract override /*1*/ /*fake_override*/ fun size(): kotlin.Int
+        public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.MutableList<E>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilityGenericSubclassSimple {
+
+    public trait Super {
+        public fun foo(): MutableCollection<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilityGenericSubclassSimple {
+
+    public trait Sub : test.InheritNullabilityGenericSubclassSimple.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableCollection<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilityJavaSubtype {
+
+    public trait Super {
+        public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilityJavaSubtype {
+
+    public trait Sub : test.InheritNullabilityJavaSubtype.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilitySameGenericType {
+
+    public trait Super {
+        public fun foo(): MutableList<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilitySameGenericType {
+
+    public trait Sub : test.InheritNullabilitySameGenericType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableList<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilitySameJavaType {
+
+    public trait Super {
+        public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritNullabilitySameJavaType {
+
+    public trait Sub : test.InheritNullabilitySameJavaType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.CharSequence
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.CharSequence
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritProjectionKind.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritProjectionKind {
+
+    public trait Super {
+        public fun foo(): MutableCollection<out Number>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<out Number>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritProjectionKind.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritProjectionKind {
+
+    public trait Sub : test.InheritProjectionKind.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableList<out kotlin.Number>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableCollection<out kotlin.Number>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessOfArgument {
+
+    public trait Super {
+        public fun foo(): List<List<String>>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): List<List<String>>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessOfArgument {
+
+    public trait Sub : test.InheritReadOnlinessOfArgument.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.List<kotlin.List<kotlin.String>>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.List<kotlin.List<kotlin.String>>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessSameClass {
+
+    public trait Super {
+        public fun foo(): List<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): List<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessSameClass {
+
+    public trait Sub : test.InheritReadOnlinessSameClass.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.List<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.List<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessSubclass {
+
+    public trait Super {
+        public fun foo(): Collection<String>
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): List<String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait InheritReadOnlinessSubclass {
+
+    public trait Sub : test.InheritReadOnlinessSubclass.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.List<kotlin.String>
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.Collection<kotlin.String>
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SameProjectionKind.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait SameProjectionKind {
+
+    public trait Super {
+        public fun foo(): MutableCollection<out Number?>?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableCollection<out Number?>?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SameProjectionKind.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait SameProjectionKind {
+
+    public trait Sub : test.SameProjectionKind.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.MutableCollection<out kotlin.Number?>?
+    }
+
+    public trait Super {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.MutableCollection<out kotlin.Number?>?
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt

@@ -0,0 +1,20 @@
+package test
+
+public trait SubclassFromGenericAndNot {
+
+    public trait NonGeneric  {
+        public fun foo(): String?
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Generic<T>  {
+        public fun foo(): T
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub : NonGeneric, Generic<String> {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt

@@ -0,0 +1,19 @@
+package test
+
+public trait SubclassFromGenericAndNot {
+
+    public trait Generic</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): T
+    }
+
+    public trait NonGeneric {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): kotlin.String?
+    }
+
+    public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<kotlin.String> {
+        public abstract override /*2*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*2*/ fun foo(): kotlin.String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt

@@ -0,0 +1,5 @@
+package test
+
+public trait SubclassOfCollection<E>: MutableCollection<E> {
+    override fun iterator() : MutableIterator<E>
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.txt

@@ -0,0 +1,15 @@
+package test
+
+public trait SubclassOfCollection</*0*/ E> : kotlin.MutableCollection<E> {
+    public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ e: E): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: kotlin.Collection<E>): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit
+    public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean
+    public abstract override /*1*/ fun iterator(): kotlin.MutableIterator<E>
+    public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ o: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: kotlin.Collection<kotlin.Any?>): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun size(): kotlin.Int
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.kt

@@ -0,0 +1,5 @@
+package test
+
+public trait SubclassOfMapEntry<K, V>: MutableMap.MutableEntry<K, V> {
+    override fun setValue(value: V) : V
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.txt

@@ -0,0 +1,7 @@
+package test
+
+public trait SubclassOfMapEntry</*0*/ K, /*1*/ V> : kotlin.MutableMap.MutableEntry<K, V> {
+    public abstract override /*1*/ /*fake_override*/ fun getKey(): K
+    public abstract override /*1*/ /*fake_override*/ fun getValue(): V
+    public abstract override /*1*/ fun setValue(/*0*/ value: V): V
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt

@@ -0,0 +1,14 @@
+package test
+
+public trait SubstitutedClassParameter {
+
+    public trait Super<T> {
+        public fun foo(): T
+
+        public fun dummy() // to avoid loading as SAM interface
+    }
+
+    public trait Sub: Super<String> {
+        override fun foo(): String
+    }
+}

compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.txt

@@ -0,0 +1,14 @@
+package test
+
+public trait SubstitutedClassParameter {
+
+    public trait Sub : test.SubstitutedClassParameter.Super<kotlin.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit
+        public abstract override /*1*/ fun foo(): kotlin.String
+    }
+
+    public trait Super</*0*/ T> {
+        public abstract fun dummy(): kotlin.Unit
+        public abstract fun foo(): T
+    }
+}