Added dummy methods to avoid loading test interfaces as SAM.

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java

@@ -10,6 +10,8 @@ public interface ChangeProjectionKind1 {
     public interface Super {
         @KotlinSignature("fun foo(p: MutableList<in String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt

@@ -4,6 +4,8 @@ public trait ChangeProjectionKind1: Object {
 
     public trait Super: Object {
         public fun foo(p0: MutableList<in String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt

@@ -3,10 +3,12 @@ package test
 public trait ChangeProjectionKind1 : java.lang.Object {
     
     public trait Sub : test.ChangeProjectionKind1.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java

@@ -10,6 +10,8 @@ public interface ChangeProjectionKind2 {
     public interface Super {
         @KotlinSignature("fun foo(p: MutableList<String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt

@@ -4,6 +4,8 @@ public trait ChangeProjectionKind2: Object {
 
     public trait Super: Object {
         public fun foo(p0: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt

@@ -3,10 +3,12 @@ package test
 public trait ChangeProjectionKind2 : java.lang.Object {
     
     public trait Sub : test.ChangeProjectionKind2.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java

@@ -8,6 +8,8 @@ public interface DeeplySubstitutedClassParameter {
     public interface Super<T> {
         @KotlinSignature("fun foo(t: T)")
         void foo(T p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Middle<E> extends Super<E> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt

@@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter: Object {
 
     public trait Super<T>: Object {
         public fun foo(p0: T)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Middle<E>: Super<E> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt

@@ -3,14 +3,17 @@ package test
 public trait DeeplySubstitutedClassParameter : java.lang.Object {
     
     public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : E) : jet.Unit
     }
     
     public trait Sub : test.DeeplySubstitutedClassParameter.Middle<jet.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java

@@ -8,6 +8,8 @@ public interface DeeplySubstitutedClassParameter2 {
     public interface Super<T> {
         @KotlinSignature("fun foo(t: T)")
         void foo(T p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Middle<E> extends Super<E> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt

@@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter2: Object {
 
     public trait Super<T>: Object {
         public fun foo(p0: T)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Middle<E>: Super<E> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt

@@ -3,14 +3,17 @@ package test
 public trait DeeplySubstitutedClassParameter2 : java.lang.Object {
     
     public trait Middle</*0*/ E> : test.DeeplySubstitutedClassParameter2.Super<E> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ p0 : E) : jet.Unit
     }
     
     public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<jet.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.java

@@ -10,6 +10,8 @@ public interface InheritMutability {
     public interface Super {
         @KotlinSignature("fun foo(p: MutableList<String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt

@@ -4,6 +4,8 @@ public trait InheritMutability: Object {
 
     public trait Super: Object {
         public fun foo(p0: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritMutability : java.lang.Object {
     
     public trait Sub : test.InheritMutability.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.java

@@ -4,6 +4,8 @@ public interface InheritNotVararg {
 
     public interface Super {
         void foo(String[] p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.kt

@@ -4,6 +4,8 @@ public trait InheritNotVararg: Object {
 
     public trait Super: Object {
         public fun foo(p0: Array<out String>?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritNotVararg : java.lang.Object {
     
     public trait Sub : test.InheritNotVararg.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java

@@ -4,6 +4,8 @@ public interface InheritNotVarargInteger {
 
     public interface Super {
         void foo(Integer[] p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt

@@ -4,6 +4,8 @@ public trait InheritNotVarargInteger: Object {
 
     public trait Super: Object {
         public fun foo(p0: Array<out Int>?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritNotVarargInteger : java.lang.Object {
     
     public trait Sub : test.InheritNotVarargInteger.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.Array<out jet.Int>?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java

@@ -7,6 +7,8 @@ public interface InheritNotVarargNotNull {
     public interface Super {
         @KotlinSignature("fun foo(p: Array<out String>)")
         void foo(String[] p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt

@@ -4,6 +4,8 @@ public trait InheritNotVarargNotNull: Object {
 
     public trait Super: Object {
         public fun foo(p0: Array<out String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritNotVarargNotNull : java.lang.Object {
     
     public trait Sub : test.InheritNotVarargNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.Array<out jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.Array<out jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java

@@ -4,6 +4,8 @@ public interface InheritNotVarargPrimitive {
 
     public interface Super {
         void foo(int[] p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt

@@ -4,6 +4,8 @@ public trait InheritNotVarargPrimitive: Object {
 
     public trait Super: Object {
         public fun foo(p0: IntArray?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritNotVarargPrimitive : java.lang.Object {
     
     public trait Sub : test.InheritNotVarargPrimitive.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.IntArray?) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.IntArray?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.java

@@ -6,6 +6,8 @@ public interface InheritNullability {
 
     public interface Super {
         void foo(@NotNull String p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.kt

@@ -4,6 +4,8 @@ public trait InheritNullability: Object {
 
     public trait Super: Object {
         public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritNullability : java.lang.Object {
     
     public trait Sub : test.InheritNullability.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.java

@@ -10,6 +10,8 @@ public interface InheritProjectionKind {
     public interface Super {
         @KotlinSignature("fun foo(p: MutableList<in String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt

@@ -4,6 +4,8 @@ public trait InheritProjectionKind: Object {
 
     public trait Super: Object {
         public fun foo(p0: MutableList<in String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritProjectionKind : java.lang.Object {
     
     public trait Sub : test.InheritProjectionKind.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.MutableList<in jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.java

@@ -10,6 +10,8 @@ public interface InheritReadOnliness {
     public interface Super {
         @KotlinSignature("fun foo(p: List<String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt

@@ -4,6 +4,8 @@ public trait InheritReadOnliness: Object {
 
     public trait Super: Object {
         public fun foo(p0: List<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritReadOnliness : java.lang.Object {
     
     public trait Sub : test.InheritReadOnliness.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.java

@@ -4,6 +4,8 @@ public interface InheritVararg {
 
     public interface Super {
         void foo(String... p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.kt

@@ -4,6 +4,8 @@ public trait InheritVararg: Object {
 
     public trait Super: Object {
         public fun foo(vararg p0: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritVararg : java.lang.Object {
     
     public trait Sub : test.InheritVararg.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ vararg p0 : jet.String? /*jet.Array<jet.String?>*/) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.java

@@ -4,6 +4,8 @@ public interface InheritVarargInteger {
 
     public interface Super {
         void foo(Integer... p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.kt

@@ -4,6 +4,8 @@ public trait InheritVarargInteger: Object {
 
     public trait Super: Object {
         public fun foo(vararg p0: Int?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritVarargInteger : java.lang.Object {
     
     public trait Sub : test.InheritVarargInteger.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ vararg p0 : jet.Int? /*jet.Array<jet.Int?>*/) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.java

@@ -7,6 +7,8 @@ public interface InheritVarargNotNull {
     public interface Super {
         @KotlinSignature("fun foo(vararg p: String)")
         void foo(String... p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt

@@ -4,6 +4,8 @@ public trait InheritVarargNotNull: Object {
 
     public trait Super: Object {
         public fun foo(vararg p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritVarargNotNull : java.lang.Object {
     
     public trait Sub : test.InheritVarargNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ vararg p0 : jet.String /*jet.Array<jet.String>*/) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java

@@ -4,6 +4,8 @@ public interface InheritVarargPrimitive {
 
     public interface Super {
         void foo(int... p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt

@@ -4,6 +4,8 @@ public trait InheritVarargPrimitive: Object {
 
     public trait Super: Object {
         public fun foo(vararg p0: Int)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt

@@ -3,10 +3,12 @@ package test
 public trait InheritVarargPrimitive : java.lang.Object {
     
     public trait Sub : test.InheritVarargPrimitive.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ vararg p0 : jet.Int /*jet.IntArray*/) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.java

@@ -7,11 +7,15 @@ import jet.runtime.typeinfo.KotlinSignature;
 public interface Kt3302 {
     public interface BSONObject {
         Object put(@NotNull String s, @NotNull Object o);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface LinkedHashMap<K, V> {
         @KotlinSignature("fun put(key : K, value : V) : V?")
         public V put(K key, V value);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface BasicBSONObject extends LinkedHashMap<String, Object>, BSONObject {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt

@@ -4,10 +4,14 @@ package test
 public trait Kt3302: Object {
     public trait BSONObject : Object {
         public fun put(p0: String, p1: Any): Any?
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait LinkedHashMap<K, V> : Object {
         public fun put(p0: K, p1: V): V?
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait BasicBSONObject : LinkedHashMap<String, Any>, BSONObject {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt

@@ -3,14 +3,17 @@ package test
 public trait Kt3302 : java.lang.Object {
     
     public trait BSONObject : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun put(/*0*/ p0 : jet.String, /*1*/ p1 : jet.Any) : jet.Any?
     }
     
     public trait BasicBSONObject : test.Kt3302.LinkedHashMap<jet.String, jet.Any>, test.Kt3302.BSONObject {
+        public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*2*/ fun put(/*0*/ p0 : jet.String, /*1*/ p1 : jet.Any) : jet.Any?
     }
     
     public trait LinkedHashMap</*0*/ K, /*1*/ V> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun put(/*0*/ p0 : K, /*1*/ p1 : V) : V?
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.java

@@ -10,6 +10,8 @@ public interface MutableToReadOnly {
     public interface Super {
         @KotlinSignature("fun foo(p: MutableList<String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt

@@ -4,6 +4,8 @@ public trait MutableToReadOnly: Object {
 
     public trait Super: Object {
         public fun foo(p0: MutableList<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt

@@ -3,10 +3,12 @@ package test
 public trait MutableToReadOnly : java.lang.Object {
     
     public trait Sub : test.MutableToReadOnly.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.MutableList<jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.java

@@ -8,6 +8,8 @@ public interface NotNullToNullable {
 
     public interface Super {
         void foo(@NotNull String p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.kt

@@ -4,6 +4,8 @@ public trait NotNullToNullable: Object {
 
     public trait Super: Object {
         public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.txt

@@ -3,10 +3,12 @@ package test
 public trait NotNullToNullable : java.lang.Object {
     
     public trait Sub : test.NotNullToNullable.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.java

@@ -8,6 +8,8 @@ public interface NullableToNotNull {
 
     public interface Super {
         void foo(String p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.kt

@@ -4,6 +4,8 @@ public trait NullableToNotNull: Object {
 
     public trait Super: Object {
         public fun foo(p0: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.txt

@@ -3,10 +3,12 @@ package test
 public trait NullableToNotNull : java.lang.Object {
     
     public trait Sub : test.NullableToNotNull.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.String?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java

@@ -9,6 +9,8 @@ public interface NullableToNotNullKotlinSignature {
     public interface Super {
         @KotlinSignature("fun foo(p: String?)")
         void foo(String p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt

@@ -4,6 +4,8 @@ public trait NullableToNotNullKotlinSignature: Object {
 
     public trait Super: Object {
         public fun foo(p0: String?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt

@@ -3,10 +3,12 @@ package test
 public trait NullableToNotNullKotlinSignature : java.lang.Object {
     
     public trait Sub : test.NullableToNotNullKotlinSignature.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String?) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.String?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java

@@ -4,6 +4,8 @@ public interface OverrideWithErasedParameter  {
 
     public interface Super<T> {
         void foo(T t);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub<T> extends Super<T> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt

@@ -4,6 +4,8 @@ public trait OverrideWithErasedParameter: Object {
 
     public trait Super<T>: Object {
         public fun foo(p0: T?)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub<T>: Super<T> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt

@@ -3,10 +3,12 @@ package test
 public trait OverrideWithErasedParameter : java.lang.Object {
     
     public trait Sub</*0*/ T> : test.OverrideWithErasedParameter.Super<T> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : T?) : jet.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T?) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java

@@ -10,6 +10,8 @@ public interface ReadOnlyToMutable {
     public interface Super {
         @KotlinSignature("fun foo(p: List<String>)")
         void foo(List<String> p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt

@@ -4,6 +4,8 @@ public trait ReadOnlyToMutable: Object {
 
     public trait Super: Object {
         public fun foo(p0: List<String>)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt

@@ -3,10 +3,12 @@ package test
 public trait ReadOnlyToMutable : java.lang.Object {
     
     public trait Sub : test.ReadOnlyToMutable.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.List<jet.String>) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java

@@ -8,11 +8,15 @@ public interface SubclassFromGenericAndNot {
 
     public interface NonGeneric {
         void foo(@NotNull String s);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Generic<T> {
         @KotlinSignature("fun foo(key : T)")
         public void foo(T key);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends NonGeneric, Generic<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt

@@ -5,10 +5,14 @@ public trait SubclassFromGenericAndNot: Object {
 
     public trait NonGeneric : Object {
         public fun foo(p0: String)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Generic<T> : Object {
         public fun foo(p0: T)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub : NonGeneric, Generic<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt

@@ -3,14 +3,17 @@ package test
 public trait SubclassFromGenericAndNot : java.lang.Object {
     
     public trait Generic</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T) : jet.Unit
     }
     
     public trait NonGeneric : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<jet.String> {
+        public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java

@@ -8,6 +8,8 @@ public interface SubstitutedClassParameter {
     public interface Super<T> {
         @KotlinSignature("fun foo(t: T)")
         void foo(T p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt

@@ -4,6 +4,8 @@ public trait SubstitutedClassParameter: Object {
 
     public trait Super<T>: Object {
         public fun foo(p0: T)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt

@@ -3,10 +3,12 @@ package test
 public trait SubstitutedClassParameter : java.lang.Object {
     
     public trait Sub : test.SubstitutedClassParameter.Super<jet.String> {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java

@@ -8,11 +8,15 @@ public interface SubstitutedClassParameters {
     public interface Super1<T> {
         @KotlinSignature("fun foo(t: T)")
         void foo(T p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Super2<E> {
         @KotlinSignature("fun foo(t: E)")
         void foo(E p);
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super1<String>, Super2<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt

@@ -4,10 +4,14 @@ public trait SubstitutedClassParameters: Object {
 
     public trait Super1<T>: Object {
         public fun foo(p0: T)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Super2<E>: Object {
         public fun foo(p0: E)
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super1<String>, Super2<String> {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt

@@ -3,14 +3,17 @@ package test
 public trait SubstitutedClassParameters : java.lang.Object {
     
     public trait Sub : test.SubstitutedClassParameters.Super1<jet.String>, test.SubstitutedClassParameters.Super2<jet.String> {
+        public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit
     }
     
     public trait Super1</*0*/ T> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : T) : jet.Unit
     }
     
     public trait Super2</*0*/ E> : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo(/*0*/ p0 : E) : jet.Unit
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java

@@ -6,6 +6,8 @@ public interface AddNotNullJavaSubtype {
 
     public interface Super {
         CharSequence foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt

@@ -4,6 +4,8 @@ public trait AddNotNullJavaSubtype : Object {
 
     public trait Super: Object {
         public fun foo(): CharSequence?
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNotNullJavaSubtype : java.lang.Object {
     
     public trait Sub : test.AddNotNullJavaSubtype.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.String
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.CharSequence?
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.java

@@ -6,6 +6,8 @@ public interface AddNotNullSameJavaType {
 
     public interface Super {
         CharSequence foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt

@@ -4,6 +4,8 @@ public trait AddNotNullSameJavaType: Object {
 
     public trait Super: Object {
         public fun foo(): CharSequence?
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNotNullSameJavaType : java.lang.Object {
     
     public trait Sub : test.AddNotNullSameJavaType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.CharSequence
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.CharSequence?
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java

@@ -9,6 +9,8 @@ public interface AddNullabilityJavaSubtype {
     public interface Super {
         @NotNull
         CharSequence foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt

@@ -4,6 +4,8 @@ public trait AddNullabilityJavaSubtype: Object {
 
     public trait Super: Object {
         public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNullabilityJavaSubtype : java.lang.Object {
     
     public trait Sub : test.AddNullabilityJavaSubtype.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.String
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.CharSequence
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java

@@ -10,6 +10,8 @@ public interface AddNullabilitySameGenericType1 {
     public interface Super {
         @KotlinSignature("fun foo(): MutableList<String>")
         List<String> foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt

@@ -4,6 +4,8 @@ public trait AddNullabilitySameGenericType1: Object {
 
     public trait Super: Object {
         public fun foo(): MutableList<String>
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNullabilitySameGenericType1 : java.lang.Object {
     
     public trait Sub : test.AddNullabilitySameGenericType1.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.MutableList<jet.String>
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.MutableList<jet.String>
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java

@@ -10,6 +10,8 @@ public interface AddNullabilitySameGenericType2 {
     public interface Super {
         @KotlinSignature("fun foo(): MutableList<String>")
         List<String> foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt

@@ -4,6 +4,8 @@ public trait AddNullabilitySameGenericType2: Object {
 
     public trait Super: Object {
         public fun foo(): MutableList<String>
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNullabilitySameGenericType2 : java.lang.Object {
     
     public trait Sub : test.AddNullabilitySameGenericType2.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.MutableList<jet.String>
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.MutableList<jet.String>
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java

@@ -10,6 +10,8 @@ public interface AddNullabilitySameJavaType {
     public interface Super {
         @NotNull
         CharSequence foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt

@@ -4,6 +4,8 @@ public trait AddNullabilitySameJavaType: Object {
 
     public trait Super: Object {
         public fun foo(): CharSequence
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt

@@ -3,10 +3,12 @@ package test
 public trait AddNullabilitySameJavaType : java.lang.Object {
     
     public trait Sub : test.AddNullabilitySameJavaType.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.CharSequence
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.CharSequence
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java

@@ -11,6 +11,8 @@ public interface CantMakeImmutableInSubclass {
     public interface Super {
         @KotlinSignature("fun foo(): MutableCollection<String>")
         Collection<String> foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Sub extends Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt

@@ -4,6 +4,8 @@ public trait CantMakeImmutableInSubclass: Object {
 
     public trait Super: Object {
         public fun foo(): MutableCollection<String>
+
+        public fun dummy() // to avoid loading as SAM interface
     }
 
     public trait Sub: Super {

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.txt

@@ -3,10 +3,12 @@ package test
 public trait CantMakeImmutableInSubclass : java.lang.Object {
     
     public trait Sub : test.CantMakeImmutableInSubclass.Super {
+        public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit
         public abstract override /*1*/ fun foo() : jet.MutableList<jet.String>
     }
     
     public trait Super : java.lang.Object {
+        public abstract fun dummy() : jet.Unit
         public abstract fun foo() : jet.MutableCollection<jet.String>
     }
 }

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java

@@ -10,6 +10,8 @@ public interface DeeplySubstitutedClassParameter {
     public interface Super<T> {
         @KotlinSignature("fun foo(): T")
         T foo();
+
+        void dummy(); // to avoid loading as SAM interface
     }
 
     public interface Middle<E> extends Super<E> {