From 4fc1148d5935a6cba75a690b24bd380d109c4d40 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Wed, 27 Mar 2013 16:27:23 +0400 Subject: [PATCH] Added dummy methods to avoid loading test interfaces as SAM. --- .../propagation/parameter/ChangeProjectionKind1.java | 2 ++ .../propagation/parameter/ChangeProjectionKind1.kt | 2 ++ .../propagation/parameter/ChangeProjectionKind1.txt | 2 ++ .../propagation/parameter/ChangeProjectionKind2.java | 2 ++ .../propagation/parameter/ChangeProjectionKind2.kt | 2 ++ .../propagation/parameter/ChangeProjectionKind2.txt | 2 ++ .../parameter/DeeplySubstitutedClassParameter.java | 2 ++ .../propagation/parameter/DeeplySubstitutedClassParameter.kt | 2 ++ .../propagation/parameter/DeeplySubstitutedClassParameter.txt | 3 +++ .../parameter/DeeplySubstitutedClassParameter2.java | 2 ++ .../propagation/parameter/DeeplySubstitutedClassParameter2.kt | 2 ++ .../parameter/DeeplySubstitutedClassParameter2.txt | 3 +++ .../propagation/parameter/InheritMutability.java | 2 ++ .../propagation/parameter/InheritMutability.kt | 2 ++ .../propagation/parameter/InheritMutability.txt | 2 ++ .../propagation/parameter/InheritNotVararg.java | 2 ++ .../kotlinSignature/propagation/parameter/InheritNotVararg.kt | 2 ++ .../propagation/parameter/InheritNotVararg.txt | 2 ++ .../propagation/parameter/InheritNotVarargInteger.java | 2 ++ .../propagation/parameter/InheritNotVarargInteger.kt | 2 ++ .../propagation/parameter/InheritNotVarargInteger.txt | 2 ++ .../propagation/parameter/InheritNotVarargNotNull.java | 2 ++ .../propagation/parameter/InheritNotVarargNotNull.kt | 2 ++ .../propagation/parameter/InheritNotVarargNotNull.txt | 2 ++ .../propagation/parameter/InheritNotVarargPrimitive.java | 2 ++ .../propagation/parameter/InheritNotVarargPrimitive.kt | 2 ++ .../propagation/parameter/InheritNotVarargPrimitive.txt | 2 ++ .../propagation/parameter/InheritNullability.java | 2 ++ .../propagation/parameter/InheritNullability.kt | 2 ++ .../propagation/parameter/InheritNullability.txt | 2 ++ .../propagation/parameter/InheritProjectionKind.java | 2 ++ .../propagation/parameter/InheritProjectionKind.kt | 2 ++ .../propagation/parameter/InheritProjectionKind.txt | 2 ++ .../propagation/parameter/InheritReadOnliness.java | 2 ++ .../propagation/parameter/InheritReadOnliness.kt | 2 ++ .../propagation/parameter/InheritReadOnliness.txt | 2 ++ .../kotlinSignature/propagation/parameter/InheritVararg.java | 2 ++ .../kotlinSignature/propagation/parameter/InheritVararg.kt | 2 ++ .../kotlinSignature/propagation/parameter/InheritVararg.txt | 2 ++ .../propagation/parameter/InheritVarargInteger.java | 2 ++ .../propagation/parameter/InheritVarargInteger.kt | 2 ++ .../propagation/parameter/InheritVarargInteger.txt | 2 ++ .../propagation/parameter/InheritVarargNotNull.java | 2 ++ .../propagation/parameter/InheritVarargNotNull.kt | 2 ++ .../propagation/parameter/InheritVarargNotNull.txt | 2 ++ .../propagation/parameter/InheritVarargPrimitive.java | 2 ++ .../propagation/parameter/InheritVarargPrimitive.kt | 2 ++ .../propagation/parameter/InheritVarargPrimitive.txt | 2 ++ .../kotlinSignature/propagation/parameter/Kt3302.java | 4 ++++ .../kotlinSignature/propagation/parameter/Kt3302.kt | 4 ++++ .../kotlinSignature/propagation/parameter/Kt3302.txt | 3 +++ .../propagation/parameter/MutableToReadOnly.java | 2 ++ .../propagation/parameter/MutableToReadOnly.kt | 2 ++ .../propagation/parameter/MutableToReadOnly.txt | 2 ++ .../propagation/parameter/NotNullToNullable.java | 2 ++ .../propagation/parameter/NotNullToNullable.kt | 2 ++ .../propagation/parameter/NotNullToNullable.txt | 2 ++ .../propagation/parameter/NullableToNotNull.java | 2 ++ .../propagation/parameter/NullableToNotNull.kt | 2 ++ .../propagation/parameter/NullableToNotNull.txt | 2 ++ .../parameter/NullableToNotNullKotlinSignature.java | 2 ++ .../propagation/parameter/NullableToNotNullKotlinSignature.kt | 2 ++ .../parameter/NullableToNotNullKotlinSignature.txt | 2 ++ .../propagation/parameter/OverrideWithErasedParameter.java | 2 ++ .../propagation/parameter/OverrideWithErasedParameter.kt | 2 ++ .../propagation/parameter/OverrideWithErasedParameter.txt | 2 ++ .../propagation/parameter/ReadOnlyToMutable.java | 2 ++ .../propagation/parameter/ReadOnlyToMutable.kt | 2 ++ .../propagation/parameter/ReadOnlyToMutable.txt | 2 ++ .../propagation/parameter/SubclassFromGenericAndNot.java | 4 ++++ .../propagation/parameter/SubclassFromGenericAndNot.kt | 4 ++++ .../propagation/parameter/SubclassFromGenericAndNot.txt | 3 +++ .../propagation/parameter/SubstitutedClassParameter.java | 2 ++ .../propagation/parameter/SubstitutedClassParameter.kt | 2 ++ .../propagation/parameter/SubstitutedClassParameter.txt | 2 ++ .../propagation/parameter/SubstitutedClassParameters.java | 4 ++++ .../propagation/parameter/SubstitutedClassParameters.kt | 4 ++++ .../propagation/parameter/SubstitutedClassParameters.txt | 3 +++ .../propagation/return/AddNotNullJavaSubtype.java | 2 ++ .../propagation/return/AddNotNullJavaSubtype.kt | 2 ++ .../propagation/return/AddNotNullJavaSubtype.txt | 2 ++ .../propagation/return/AddNotNullSameJavaType.java | 2 ++ .../propagation/return/AddNotNullSameJavaType.kt | 2 ++ .../propagation/return/AddNotNullSameJavaType.txt | 2 ++ .../propagation/return/AddNullabilityJavaSubtype.java | 2 ++ .../propagation/return/AddNullabilityJavaSubtype.kt | 2 ++ .../propagation/return/AddNullabilityJavaSubtype.txt | 2 ++ .../propagation/return/AddNullabilitySameGenericType1.java | 2 ++ .../propagation/return/AddNullabilitySameGenericType1.kt | 2 ++ .../propagation/return/AddNullabilitySameGenericType1.txt | 2 ++ .../propagation/return/AddNullabilitySameGenericType2.java | 2 ++ .../propagation/return/AddNullabilitySameGenericType2.kt | 2 ++ .../propagation/return/AddNullabilitySameGenericType2.txt | 2 ++ .../propagation/return/AddNullabilitySameJavaType.java | 2 ++ .../propagation/return/AddNullabilitySameJavaType.kt | 2 ++ .../propagation/return/AddNullabilitySameJavaType.txt | 2 ++ .../propagation/return/CantMakeImmutableInSubclass.java | 2 ++ .../propagation/return/CantMakeImmutableInSubclass.kt | 2 ++ .../propagation/return/CantMakeImmutableInSubclass.txt | 2 ++ .../propagation/return/DeeplySubstitutedClassParameter.java | 2 ++ .../propagation/return/DeeplySubstitutedClassParameter.kt | 2 ++ .../propagation/return/DeeplySubstitutedClassParameter.txt | 3 +++ .../propagation/return/DeeplySubstitutedClassParameter2.java | 2 ++ .../propagation/return/DeeplySubstitutedClassParameter2.kt | 2 ++ .../propagation/return/DeeplySubstitutedClassParameter2.txt | 3 +++ .../propagation/return/HalfSubstitutedTypeParameters.java | 2 ++ .../propagation/return/HalfSubstitutedTypeParameters.kt | 2 ++ .../propagation/return/HalfSubstitutedTypeParameters.txt | 2 ++ .../return/InheritNullabilityGenericSubclassSimple.java | 2 ++ .../return/InheritNullabilityGenericSubclassSimple.kt | 2 ++ .../return/InheritNullabilityGenericSubclassSimple.txt | 2 ++ .../propagation/return/InheritNullabilityJavaSubtype.java | 2 ++ .../propagation/return/InheritNullabilityJavaSubtype.kt | 2 ++ .../propagation/return/InheritNullabilityJavaSubtype.txt | 2 ++ .../propagation/return/InheritNullabilitySameGenericType.java | 2 ++ .../propagation/return/InheritNullabilitySameGenericType.kt | 2 ++ .../propagation/return/InheritNullabilitySameGenericType.txt | 2 ++ .../propagation/return/InheritNullabilitySameJavaType.java | 2 ++ .../propagation/return/InheritNullabilitySameJavaType.kt | 2 ++ .../propagation/return/InheritNullabilitySameJavaType.txt | 2 ++ .../propagation/return/InheritProjectionKind.java | 2 ++ .../propagation/return/InheritProjectionKind.kt | 2 ++ .../propagation/return/InheritProjectionKind.txt | 2 ++ .../propagation/return/InheritReadOnlinessOfArgument.java | 2 ++ .../propagation/return/InheritReadOnlinessOfArgument.kt | 2 ++ .../propagation/return/InheritReadOnlinessOfArgument.txt | 2 ++ .../propagation/return/InheritReadOnlinessSameClass.java | 2 ++ .../propagation/return/InheritReadOnlinessSameClass.kt | 2 ++ .../propagation/return/InheritReadOnlinessSameClass.txt | 2 ++ .../propagation/return/InheritReadOnlinessSubclass.java | 2 ++ .../propagation/return/InheritReadOnlinessSubclass.kt | 2 ++ .../propagation/return/InheritReadOnlinessSubclass.txt | 2 ++ .../propagation/return/SameProjectionKind.java | 2 ++ .../kotlinSignature/propagation/return/SameProjectionKind.kt | 2 ++ .../kotlinSignature/propagation/return/SameProjectionKind.txt | 2 ++ .../propagation/return/SubclassFromGenericAndNot.java | 4 ++++ .../propagation/return/SubclassFromGenericAndNot.kt | 4 ++++ .../propagation/return/SubclassFromGenericAndNot.txt | 3 +++ .../propagation/return/SubstitutedClassParameter.java | 2 ++ .../propagation/return/SubstitutedClassParameter.kt | 2 ++ .../propagation/return/SubstitutedClassParameter.txt | 2 ++ .../propagation/return/SubstitutedClassParameters.java | 4 ++++ .../propagation/return/SubstitutedClassParameters.kt | 4 ++++ .../propagation/return/SubstitutedClassParameters.txt | 3 +++ .../return/TwoSuperclassesConflictingProjectionKinds.java | 4 ++++ .../return/TwoSuperclassesConflictingProjectionKinds.kt | 4 ++++ .../return/TwoSuperclassesConflictingProjectionKinds.txt | 3 +++ .../TwoSuperclassesInvariantAndCovariantInferMutability.java | 4 ++++ .../TwoSuperclassesInvariantAndCovariantInferMutability.kt | 4 ++++ .../TwoSuperclassesInvariantAndCovariantInferMutability.txt | 3 +++ .../TwoSuperclassesInvariantAndCovariantInferNullability.java | 4 ++++ .../TwoSuperclassesInvariantAndCovariantInferNullability.kt | 4 ++++ .../TwoSuperclassesInvariantAndCovariantInferNullability.txt | 3 +++ .../propagation/return/TwoSuperclassesMutableAndNot.java | 4 ++++ .../propagation/return/TwoSuperclassesMutableAndNot.kt | 4 ++++ .../propagation/return/TwoSuperclassesMutableAndNot.txt | 3 +++ .../propagation/return/TwoSuperclassesReturnJavaSubtype.java | 4 ++++ .../propagation/return/TwoSuperclassesReturnJavaSubtype.kt | 4 ++++ .../propagation/return/TwoSuperclassesReturnJavaSubtype.txt | 3 +++ .../propagation/return/TwoSuperclassesReturnSameJavaType.java | 4 ++++ .../propagation/return/TwoSuperclassesReturnSameJavaType.kt | 4 ++++ .../propagation/return/TwoSuperclassesReturnSameJavaType.txt | 3 +++ .../propagation/return/TwoSuperclassesSupplementNotNull.java | 4 ++++ .../propagation/return/TwoSuperclassesSupplementNotNull.kt | 4 ++++ .../propagation/return/TwoSuperclassesSupplementNotNull.txt | 3 +++ .../kotlinSignature/propagation/return/TypeParamOfClass.java | 2 ++ .../kotlinSignature/propagation/return/TypeParamOfClass.kt | 2 ++ .../kotlinSignature/propagation/return/TypeParamOfClass.txt | 2 ++ .../propagation/return/TypeParamOfClassSubstituted.java | 2 ++ .../propagation/return/TypeParamOfClassSubstituted.kt | 2 ++ .../propagation/return/TypeParamOfClassSubstituted.txt | 2 ++ .../kotlinSignature/propagation/return/TypeParamOfFun.java | 2 ++ .../kotlinSignature/propagation/return/TypeParamOfFun.kt | 2 ++ .../kotlinSignature/propagation/return/TypeParamOfFun.txt | 2 ++ 174 files changed, 412 insertions(+) diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java index 465dad1dc8b..25d55fab532 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java @@ -10,6 +10,8 @@ public interface ChangeProjectionKind1 { public interface Super { @KotlinSignature("fun foo(p: MutableList)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt index ab99367048b..ecb31a4b70f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt index f97d041ffd0..924e7ef8250 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind1.txt +++ b/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) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.MutableList) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java index 39766ebf854..8934798978d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java @@ -10,6 +10,8 @@ public interface ChangeProjectionKind2 { public interface Super { @KotlinSignature("fun foo(p: MutableList)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt index 8b43676c090..d1eebda1e72 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt index 84482aa6d9c..61f23e08d30 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ChangeProjectionKind2.txt +++ b/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.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.MutableList) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java index 6119482ff6e..64a61e894c9 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java @@ -8,6 +8,8 @@ public interface DeeplySubstitutedClassParameter { public interface Super { @KotlinSignature("fun foo(t: T)") void foo(T p); + + void dummy(); // to avoid loading as SAM interface } public interface Middle extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt index f0f602bb4df..b4ff55c26af 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt @@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter: Object { public trait Super: Object { public fun foo(p0: T) + + public fun dummy() // to avoid loading as SAM interface } public trait Middle: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt index 9421966b76e..17114690489 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt @@ -3,14 +3,17 @@ package test public trait DeeplySubstitutedClassParameter : java.lang.Object { public trait Middle : test.DeeplySubstitutedClassParameter.Super { + 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 { + 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 : T) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java index 5078f2e3272..8ef8d2bfb42 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java @@ -8,6 +8,8 @@ public interface DeeplySubstitutedClassParameter2 { public interface Super { @KotlinSignature("fun foo(t: T)") void foo(T p); + + void dummy(); // to avoid loading as SAM interface } public interface Middle extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt index 25a53202837..dbbb780ac54 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt @@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter2: Object { public trait Super: Object { public fun foo(p0: T) + + public fun dummy() // to avoid loading as SAM interface } public trait Middle: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt index 2cf6009f054..e7eab388e86 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt @@ -3,14 +3,17 @@ package test public trait DeeplySubstitutedClassParameter2 : java.lang.Object { public trait Middle : test.DeeplySubstitutedClassParameter2.Super { + 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 { + 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 : T) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.java index 6d2304d504c..264382ee8c6 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.java @@ -10,6 +10,8 @@ public interface InheritMutability { public interface Super { @KotlinSignature("fun foo(p: MutableList)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt index bf5a0be738b..4fca651f5b5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt index 0d2cda78c15..bc29435060e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritMutability.txt +++ b/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.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.MutableList) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.java index 4385f4175ea..65e7304eec8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.kt index f3fde68291a..57a7f32659d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.kt +++ b/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?) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.txt index 13fb2a0c2e8..10c45ca39ee 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVararg.txt +++ b/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?) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.Array?) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java index 0892535cfd7..6a9aadf04b5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt index ae529346031..2afdced1750 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt +++ b/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?) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt index 4b42f5ad4fb..e1f89fe31f8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt +++ b/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?) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.Array?) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java index c2d95af9a08..8b31c0b317d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java @@ -7,6 +7,8 @@ public interface InheritNotVarargNotNull { public interface Super { @KotlinSignature("fun foo(p: Array)") void foo(String[] p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt index bd1d42e1406..c76e2530216 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt index 0b687dba8e8..62bd1349dc1 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.txt +++ b/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) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.Array) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java index 057b2d948f9..f9427c72811 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt index 0852029c602..be571ba103e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt index dd0bdbec6fe..ee8108eb726 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.java index 5f53c7f1061..85ae0a65db7 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.kt index 05f53fba688..8453a838ddd 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.txt index 35ee94b31a1..959554aeadd 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritNullability.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.java index 0e0e8df21ef..b7b32cead89 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.java @@ -10,6 +10,8 @@ public interface InheritProjectionKind { public interface Super { @KotlinSignature("fun foo(p: MutableList)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt index 08a435cd565..db89e8ce436 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt index 37f82ba4639..3484a6a84f0 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritProjectionKind.txt +++ b/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) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.MutableList) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.java index d077d30a550..3e0382a31af 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.java @@ -10,6 +10,8 @@ public interface InheritReadOnliness { public interface Super { @KotlinSignature("fun foo(p: List)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt index 1e6f1a0b361..ccc20f8a2ed 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt index 0d0ecb37765..3a9c25c7737 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritReadOnliness.txt +++ b/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.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.List) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.java index f8a6d4388a7..7b216c2b37a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.kt index c5dff9e67de..e0f17473c9a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.txt index 1b119110092..abca8fd2312 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVararg.txt +++ b/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.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.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.java index aadd4265d56..ebd9c98ffb9 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.kt index 7d04cf3b374..f88eb2355c5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.txt index ad4e22f5db1..c758df88793 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargInteger.txt +++ b/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.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.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.java index eef9c8fbc76..61acb5fe1ac 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt index 6556b02705f..a7e877d4989 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt index c119dde49a3..92c7670f9f8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargNotNull.txt +++ b/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.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.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java index a1708aa507e..52d95322f80 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt index 046d226ca07..aeb020e0ef5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt index 39dbc07e64e..0d3a3b66e2a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.java index 5e289de4f82..e92fb08f714 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.java +++ b/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 { @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, BSONObject { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt index d868be41dcc..ad7dd435cd2 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.kt +++ b/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 : Object { public fun put(p0: K, p1: V): V? + + public fun dummy() // to avoid loading as SAM interface } public trait BasicBSONObject : LinkedHashMap, BSONObject { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt index cadcfa9e6e1..fc627c21281 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/Kt3302.txt +++ b/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, 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 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun put(/*0*/ p0 : K, /*1*/ p1 : V) : V? } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.java index 0d7d63c73c5..0734fd54396 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.java @@ -10,6 +10,8 @@ public interface MutableToReadOnly { public interface Super { @KotlinSignature("fun foo(p: MutableList)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt index dbf8811d8e9..e02528bcceb 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt index 506f530af3e..5ba705d0356 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/MutableToReadOnly.txt +++ b/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.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.MutableList) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.java index cda3691ccba..2942e88ca90 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.kt index 84859cbafee..b71bfae63ec 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.txt index c9ac7d42c53..4447f211391 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NotNullToNullable.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.java index 9efe500dd14..00838abdb08 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.kt index 1836c6fc813..9e0dfe5e09c 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.txt index 043d0e3df5a..a6d40934847 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNull.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java index 1e1fd0b71d6..2622d91b6a9 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt index 3b2745664aa..94dc13270d4 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt index e43fe03aa5f..33f2f7bee0d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java index 56e7345920d..431ef6a6fb7 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java @@ -4,6 +4,8 @@ public interface OverrideWithErasedParameter { public interface Super { void foo(T t); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt index e40f8028fa3..9ee35b98934 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt @@ -4,6 +4,8 @@ public trait OverrideWithErasedParameter: Object { public trait Super: Object { public fun foo(p0: T?) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt index 563398031bb..020ec2cc226 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.txt @@ -3,10 +3,12 @@ package test public trait OverrideWithErasedParameter : java.lang.Object { public trait Sub : test.OverrideWithErasedParameter.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo(/*0*/ p0 : T?) : jet.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : T?) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java index ae8e99096b0..46bc164d6b9 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java @@ -10,6 +10,8 @@ public interface ReadOnlyToMutable { public interface Super { @KotlinSignature("fun foo(p: List)") void foo(List p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt index ec602361d25..1bfebc1f983 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt +++ b/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) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt index 140f43b0d4f..6af6ecfe054 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/ReadOnlyToMutable.txt +++ b/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.Unit } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : jet.List) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java index b9ef46b8dba..7dade46bdbc 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java +++ b/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 { @KotlinSignature("fun foo(key : T)") public void foo(T key); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends NonGeneric, Generic { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt index b6cfc49b4f1..a9a12f69a65 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt +++ b/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 : Object { public fun foo(p0: T) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub : NonGeneric, Generic { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt index 8e64d247aac..14abbbdc56a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt @@ -3,14 +3,17 @@ package test public trait SubclassFromGenericAndNot : java.lang.Object { public trait Generic : 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 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo(/*0*/ p0 : jet.String) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java index 87c3efd4e13..41014f12b63 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java @@ -8,6 +8,8 @@ public interface SubstitutedClassParameter { public interface Super { @KotlinSignature("fun foo(t: T)") void foo(T p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt index 24932e12ad9..acc91f47446 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt @@ -4,6 +4,8 @@ public trait SubstitutedClassParameter: Object { public trait Super: Object { public fun foo(p0: T) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt index 2337b03db1c..3e3080fd3be 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt +++ b/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 { + 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 : T) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java index 8b85e4a6643..9cb496cff4a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java @@ -8,11 +8,15 @@ public interface SubstitutedClassParameters { public interface Super1 { @KotlinSignature("fun foo(t: T)") void foo(T p); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(t: E)") void foo(E p); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt index 44b5acf7fc9..80ee6e9a6f6 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt @@ -4,10 +4,14 @@ public trait SubstitutedClassParameters: Object { public trait Super1: Object { public fun foo(p0: T) + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(p0: E) + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt index c732eee0158..dc197202c4a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt +++ b/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, test.SubstitutedClassParameters.Super2 { + 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 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : T) : jet.Unit } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo(/*0*/ p0 : E) : jet.Unit } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java index 3f549f3cb18..d74fab64700 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt index 4423bc6e1f7..67971addff9 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt index 121eb843f89..a71f28057e5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt +++ b/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? } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.java index 5edb185da4c..4a82eb85966 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt index 69889daba28..6405352cc0b 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt index f36448c80f1..08bedd9848e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt +++ b/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? } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java index 0db2e783a1f..5ebe42ac84c 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt index 5ba781fb825..1286d5a002b 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt index dce3aea8a88..c4435f10d4e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java index 6cd4db019bf..29f65e09902 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java @@ -10,6 +10,8 @@ public interface AddNullabilitySameGenericType1 { public interface Super { @KotlinSignature("fun foo(): MutableList") List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt index 3e2762854c4..d015d208ddf 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt +++ b/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 + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.txt index 6723424e57a..8cb0ddb1785 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.txt +++ b/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 } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java index dcf7c92d530..9c24c9b349d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java @@ -10,6 +10,8 @@ public interface AddNullabilitySameGenericType2 { public interface Super { @KotlinSignature("fun foo(): MutableList") List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt index 2ddaba00c5d..e911c98f22a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt +++ b/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 + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.txt index 1f69bcfd0bc..79646dc6fad 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.txt +++ b/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 } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java index 06fea01d8d3..51e88cfcf5f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt index 5b389cc01d8..48f6414f476 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt +++ b/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 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt index ef959a3d377..a9143284897 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt +++ b/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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java index 0509407a64f..6f245c36632 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java @@ -11,6 +11,8 @@ public interface CantMakeImmutableInSubclass { public interface Super { @KotlinSignature("fun foo(): MutableCollection") Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt index 33d3753b6ef..3e13c2e8d2f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt +++ b/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 + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.txt index 70906adb28a..c78629ade9e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.txt +++ b/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 } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java index 690d49bfc53..49eb91a88ad 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java @@ -10,6 +10,8 @@ public interface DeeplySubstitutedClassParameter { public interface Super { @KotlinSignature("fun foo(): T") T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Middle extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt index 30001ac557a..69d15341ce3 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt @@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Middle: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt index 8bf26d5c7c0..bb35fd911b7 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt @@ -3,14 +3,17 @@ package test public trait DeeplySubstitutedClassParameter : java.lang.Object { public trait Middle : test.DeeplySubstitutedClassParameter.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : E } public trait Sub : test.DeeplySubstitutedClassParameter.Middle { + 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() : T } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java index ed7b7716ee6..56aec8d0d6c 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java @@ -10,6 +10,8 @@ public interface DeeplySubstitutedClassParameter2 { public interface Super { @KotlinSignature("fun foo(): T") T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Middle extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt index 63be8d2e778..2ecd35992d5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt @@ -4,6 +4,8 @@ public trait DeeplySubstitutedClassParameter2: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Middle: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt index bb4c79688db..a622f2d8ca8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt @@ -3,14 +3,17 @@ package test public trait DeeplySubstitutedClassParameter2 : java.lang.Object { public trait Middle : test.DeeplySubstitutedClassParameter2.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ /*fake_override*/ fun foo() : E } public trait Sub : test.DeeplySubstitutedClassParameter2.Middle { + 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() : T } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java index 0970c4e8810..7eb91491955 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java @@ -11,6 +11,8 @@ public interface HalfSubstitutedTypeParameters { public interface Super { @KotlinSignature("fun foo(): MutableList") List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt index dc3bce94818..ab6aea374e0 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt @@ -6,6 +6,8 @@ public trait HalfSubstitutedTypeParameters: Object { public trait Super: Object { public fun foo(): MutableList + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt index fe3914eb1f0..04309ad1660 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt @@ -3,10 +3,12 @@ package test public trait HalfSubstitutedTypeParameters : java.lang.Object { public trait Sub : test.HalfSubstitutedTypeParameters.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : test.HalfSubstitutedTypeParameters.TrickyList } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java index 8d6d563ec0b..9389cf1c8d8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java @@ -11,6 +11,8 @@ public interface InheritNullabilityGenericSubclassSimple { public interface Super { @KotlinSignature("fun foo(): MutableCollection") Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt index 9579e339cd4..8b8d61c8baa 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt @@ -4,6 +4,8 @@ public trait InheritNullabilityGenericSubclassSimple: Object { public trait Super: Object { public fun foo(): MutableCollection + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.txt index 43082a344c8..20fe5cf6a07 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.txt @@ -3,10 +3,12 @@ package test public trait InheritNullabilityGenericSubclassSimple : java.lang.Object { public trait Sub : test.InheritNullabilityGenericSubclassSimple.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.MutableList } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java index 79c9828a2bf..0949c3d6e30 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java @@ -10,6 +10,8 @@ public interface InheritNullabilityJavaSubtype { public interface Super { @NotNull CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt index 39e87a688c8..370e5094ebd 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt @@ -4,6 +4,8 @@ public trait InheritNullabilityJavaSubtype: Object { public trait Super: Object { public fun foo(): CharSequence + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt index 35ed1216203..5cbb7db5301 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt @@ -3,10 +3,12 @@ package test public trait InheritNullabilityJavaSubtype : java.lang.Object { public trait Sub : test.InheritNullabilityJavaSubtype.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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java index 38d83d0eee0..98babac453c 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java @@ -10,6 +10,8 @@ public interface InheritNullabilitySameGenericType { public interface Super { @KotlinSignature("fun foo(): MutableList") List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt index cb6fd289a81..0b4f9a94ba3 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt @@ -4,6 +4,8 @@ public trait InheritNullabilitySameGenericType: Object { public trait Super: Object { public fun foo(): MutableList + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.txt index 1cd0606cf72..d9e66736863 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.txt @@ -3,10 +3,12 @@ package test public trait InheritNullabilitySameGenericType : java.lang.Object { public trait Sub : test.InheritNullabilitySameGenericType.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.MutableList } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java index b2902254194..3ec0e0316a3 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java @@ -10,6 +10,8 @@ public interface InheritNullabilitySameJavaType { public interface Super { @NotNull CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt index 94c08796afe..052832c29c0 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt @@ -4,6 +4,8 @@ public trait InheritNullabilitySameJavaType: Object { public trait Super: Object { public fun foo(): CharSequence + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt index 98c7e31c23d..40a9482669d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt @@ -3,10 +3,12 @@ package test public trait InheritNullabilitySameJavaType : java.lang.Object { public trait Sub : test.InheritNullabilitySameJavaType.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 } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.java index 4a61ab17be0..ae1e005c6a4 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.java @@ -11,6 +11,8 @@ public interface InheritProjectionKind { public interface Super { @KotlinSignature("fun foo(): MutableCollection") Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.kt index 701d1d1fb1b..75977f678f1 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.kt @@ -4,6 +4,8 @@ public trait InheritProjectionKind: Object { public trait Super: Object { public fun foo(): MutableCollection + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.txt index 5ecfe4e9863..4ed232c1800 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritProjectionKind.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/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() : jet.MutableList } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java index 0d85ce9c4cc..23154fb45e2 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java @@ -11,6 +11,8 @@ public interface InheritReadOnlinessOfArgument { public interface Super { @KotlinSignature("fun foo(): List>>") List> foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt index 4c66b87a325..7581525440d 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt @@ -4,6 +4,8 @@ public trait InheritReadOnlinessOfArgument: Object { public trait Super: Object { public fun foo(): List> + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.txt index e269e1f9908..d8c81619515 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.txt @@ -3,10 +3,12 @@ package test public trait InheritReadOnlinessOfArgument : java.lang.Object { public trait Sub : test.InheritReadOnlinessOfArgument.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.List> } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List> } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java index 3d7257b5183..64e6f3129ad 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java @@ -11,6 +11,8 @@ public interface InheritReadOnlinessSameClass { public interface Super { @KotlinSignature("fun foo(): List") List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt index 7720625c684..8a9c85232df 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt @@ -4,6 +4,8 @@ public trait InheritReadOnlinessSameClass: Object { public trait Super: Object { public fun foo(): List + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.txt index 30e8c572f21..8dad309d7dd 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.txt @@ -3,10 +3,12 @@ package test public trait InheritReadOnlinessSameClass : java.lang.Object { public trait Sub : test.InheritReadOnlinessSameClass.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.List } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java index 25879931050..d1468ff4bd3 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java @@ -11,6 +11,8 @@ public interface InheritReadOnlinessSubclass { public interface Super { @KotlinSignature("fun foo(): Collection") Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt index 75bbb2d4af9..6e352a64049 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt @@ -4,6 +4,8 @@ public trait InheritReadOnlinessSubclass: Object { public trait Super: Object { public fun foo(): Collection + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.txt index 4aef65f009d..613b4b0b543 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.txt @@ -3,10 +3,12 @@ package test public trait InheritReadOnlinessSubclass : java.lang.Object { public trait Sub : test.InheritReadOnlinessSubclass.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.List } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.Collection } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.java index 5993d20b248..206d14d43e1 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.java @@ -10,6 +10,8 @@ public interface SameProjectionKind { public interface Super { Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.kt index 5609ebd7850..877ed3d6e44 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.kt @@ -4,6 +4,8 @@ public trait SameProjectionKind: Object { public trait Super: Object { public fun foo(): MutableCollection? + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.txt index 204ecdf3ed6..93dd4e67ef7 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SameProjectionKind.txt @@ -3,10 +3,12 @@ package test public trait SameProjectionKind : java.lang.Object { public trait Sub : test.SameProjectionKind.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : jet.MutableCollection? } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection? } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java index fde78916a41..dfafd9b5ee2 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java @@ -7,11 +7,15 @@ public interface SubclassFromGenericAndNot { public interface NonGeneric { String foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Generic { @KotlinSignature("fun foo(): T") public T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends NonGeneric, Generic { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt index bce5804a0a9..a4ec7edb0f8 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt @@ -4,10 +4,14 @@ public trait SubclassFromGenericAndNot: Object { public trait NonGeneric : Object { public fun foo(): String? + + public fun dummy() // to avoid loading as SAM interface } public trait Generic : Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Sub : NonGeneric, Generic { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt index 83c5f4fd21d..791fd2ced6f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt @@ -3,14 +3,17 @@ package test public trait SubclassFromGenericAndNot : java.lang.Object { public trait Generic : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : T } public trait NonGeneric : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.String? } public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.String } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.java index ae0a9ff2243..9cf4c6ed254 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.java @@ -10,6 +10,8 @@ public interface SubstitutedClassParameter { public interface Super { @KotlinSignature("fun foo(): T") T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.kt index ddf6daf1088..201674695cd 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.kt @@ -4,6 +4,8 @@ public trait SubstitutedClassParameter: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.txt index 9e3d2765a8f..d6f1f3fed6c 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameter.txt @@ -3,10 +3,12 @@ package test public trait SubstitutedClassParameter : java.lang.Object { public trait Sub : test.SubstitutedClassParameter.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() : T } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.java index 97ab7fbdd48..3d9ddb9a084 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.java @@ -10,11 +10,15 @@ public interface SubstitutedClassParameters { public interface Super1 { @KotlinSignature("fun foo(): T") T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): E") E foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.kt index b2de7bb2fc1..5cc9877664a 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.kt @@ -4,10 +4,14 @@ public trait SubstitutedClassParameters: Object { public trait Super1: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): E + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.txt index 101723954e1..53ac54a1287 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/SubstitutedClassParameters.txt @@ -3,14 +3,17 @@ package test public trait SubstitutedClassParameters : java.lang.Object { public trait Sub : test.SubstitutedClassParameters.Super1, test.SubstitutedClassParameters.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.String } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : T } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : E } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java index 1bc38fba2a7..de58ea31710 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java @@ -11,11 +11,15 @@ public interface TwoSuperclassesConflictingProjectionKinds { public interface Super1 { @KotlinSignature("fun foo(): MutableCollection") public Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): MutableCollection") public Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt index 8a285d03d3e..84f132dfe7f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesConflictingProjectionKinds: Object { public trait Super1: Object { public fun foo(): MutableCollection + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): MutableCollection + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt index f097442f4ad..7523611b551 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesConflictingProjectionKinds : java.lang.Object { public trait Sub : test.TwoSuperclassesConflictingProjectionKinds.Super1, test.TwoSuperclassesConflictingProjectionKinds.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.MutableCollection } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java index ceefd42efe2..68702d73d27 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java @@ -9,11 +9,15 @@ public interface TwoSuperclassesInvariantAndCovariantInferMutability { public interface Super1 { @KotlinSignature("fun foo(): List>") public List> foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): MutableList>") public List> foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt index 814af6afd2a..7809805a564 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesInvariantAndCovariantInferMutability: Object { public trait Super1: Object { public fun foo(): List> + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): MutableList> + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.txt index eb3e4160454..923d798ce57 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesInvariantAndCovariantInferMutability : java.lang.Object { public trait Sub : test.TwoSuperclassesInvariantAndCovariantInferMutability.Super1, test.TwoSuperclassesInvariantAndCovariantInferMutability.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.MutableList> } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List> } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList> } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java index 654892b3345..0a466ba23bc 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java @@ -9,11 +9,15 @@ public interface TwoSuperclassesInvariantAndCovariantInferNullability { public interface Super1 { @KotlinSignature("fun foo(): List") public List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): MutableList") public List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt index 87135f5feeb..42312d42be1 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesInvariantAndCovariantInferNullability: Object { public trait Super1: Object { public fun foo(): List + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): MutableList + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.txt index e9a47ff5c4b..56d4be927c7 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesInvariantAndCovariantInferNullability : java.lang.Object { public trait Sub : test.TwoSuperclassesInvariantAndCovariantInferNullability.Super1, test.TwoSuperclassesInvariantAndCovariantInferNullability.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.MutableList } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableList } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java index a46815a4603..6a3de917116 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java @@ -9,11 +9,15 @@ public interface TwoSuperclassesMutableAndNot { public interface Super1 { @KotlinSignature("fun foo(): MutableCollection") public Collection foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): List") public List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt index 8f3cee4577f..aaf505259ae 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesMutableAndNot: Object { public trait Super1: Object { public fun foo(): MutableCollection + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): List + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt index 781b5ca1b9a..0233ab76e57 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesMutableAndNot : java.lang.Object { public trait Sub : test.TwoSuperclassesMutableAndNot.Super1, test.TwoSuperclassesMutableAndNot.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.MutableList } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.MutableCollection } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java index 0acca3a7ef1..cc132658d4f 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java @@ -7,11 +7,15 @@ public interface TwoSuperclassesReturnJavaSubtype { public interface Super1 { public CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @NotNull public CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt index 2a9f0a31176..bdd97baa335 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesReturnJavaSubtype: Object { public trait Super1: Object { public fun foo(): CharSequence? + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): CharSequence + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt index 565e143ac09..e22bcf55bff 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesReturnJavaSubtype : java.lang.Object { public trait Sub : test.TwoSuperclassesReturnJavaSubtype.Super1, test.TwoSuperclassesReturnJavaSubtype.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.String } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.CharSequence? } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.CharSequence } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java index 5cf66081e89..26579c01765 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java @@ -7,11 +7,15 @@ public interface TwoSuperclassesReturnSameJavaType { public interface Super1 { public CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @NotNull public CharSequence foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt index 3173f5da2aa..77c3c72fc5e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesReturnSameJavaType: Object { public trait Super1: Object { public fun foo(): CharSequence? + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): CharSequence + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt index a7d2ae9a887..145b674f389 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesReturnSameJavaType : java.lang.Object { public trait Sub : test.TwoSuperclassesReturnSameJavaType.Super1, test.TwoSuperclassesReturnSameJavaType.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.CharSequence } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.CharSequence? } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.CharSequence } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java index 3bed576cb0c..1a92be2f488 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java @@ -10,11 +10,15 @@ public interface TwoSuperclassesSupplementNotNull { public interface Super1 { @KotlinSignature("fun foo(): List") public List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Super2 { @KotlinSignature("fun foo(): List?") public List foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt index 7c9bdd1e066..a1c3e741efa 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt @@ -4,10 +4,14 @@ public trait TwoSuperclassesSupplementNotNull: Object { public trait Super1: Object { public fun foo(): List + + public fun dummy() // to avoid loading as SAM interface } public trait Super2: Object { public fun foo(): List? + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super1, Super2 { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt index 608aa8def56..3c2538aaee5 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt @@ -3,14 +3,17 @@ package test public trait TwoSuperclassesSupplementNotNull : java.lang.Object { public trait Sub : test.TwoSuperclassesSupplementNotNull.Super1, test.TwoSuperclassesSupplementNotNull.Super2 { + public abstract override /*2*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*2*/ fun foo() : jet.List } public trait Super1 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List } public trait Super2 : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : jet.List? } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.java index ac84c82de7a..ecc091177b6 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.java @@ -9,6 +9,8 @@ public interface TypeParamOfClass { public interface Super { @NotNull public T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.kt index 2db00d87c36..ab0371fe8d1 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.kt @@ -4,6 +4,8 @@ public trait TypeParamOfClass: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.txt index 23949522c69..11c2329dc4e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClass.txt @@ -3,10 +3,12 @@ package test public trait TypeParamOfClass : java.lang.Object { public trait Sub : test.TypeParamOfClass.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : T } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : T } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java index e67ff324d04..18a86fd0218 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java @@ -9,6 +9,8 @@ public interface TypeParamOfClassSubstituted { public interface Super { @NotNull public T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt index 66c25ccbd0d..bc88a9c200e 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt @@ -4,6 +4,8 @@ public trait TypeParamOfClassSubstituted: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt index e0c997df5f9..f0dd965fa50 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt @@ -3,10 +3,12 @@ package test public trait TypeParamOfClassSubstituted : java.lang.Object { public trait Sub : test.TypeParamOfClassSubstituted.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() : T } } diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.java b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.java index 672a52c0443..6471bf5ebcf 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.java +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.java @@ -9,6 +9,8 @@ public interface TypeParamOfFun { public interface Super { @NotNull public T foo(); + + void dummy(); // to avoid loading as SAM interface } public interface Sub extends Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.kt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.kt index 9fa963b68c5..bc8e9ce7321 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.kt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.kt @@ -4,6 +4,8 @@ public trait TypeParamOfFun: Object { public trait Super: Object { public fun foo(): T + + public fun dummy() // to avoid loading as SAM interface } public trait Sub: Super { diff --git a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.txt b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.txt index bb6a4a996eb..83a31c4b2bc 100644 --- a/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.txt +++ b/compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/return/TypeParamOfFun.txt @@ -3,10 +3,12 @@ package test public trait TypeParamOfFun : java.lang.Object { public trait Sub : test.TypeParamOfFun.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy() : jet.Unit public abstract override /*1*/ fun foo() : E } public trait Super : java.lang.Object { + public abstract fun dummy() : jet.Unit public abstract fun foo() : T } }