Moved loadJava "general" tests to subdirectory.

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.java

@@ -0,0 +1,42 @@
+package test;
+
+import java.util.List;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface PropagateTypeArgumentNullable {
+
+    public interface Super {
+
+        @KotlinSignature("fun outS(p : List<String?>)")
+        void outS(List<String> p);
+
+        @KotlinSignature("fun invOutS(p : MutableList<List<String?>>)")
+        void invOutS(List<List<String>> p);
+
+        @KotlinSignature("fun outOutS(p : List<List<String?>>)")
+        void outOutS(List<List<String>> p);
+
+        @KotlinSignature("fun outR() : List<String?>")
+        List<String> outR();
+
+        @KotlinSignature("fun invR() : MutableList<String?>")
+        List<String> invR();
+
+        @KotlinSignature("fun invOutR() : MutableList<List<String?>>")
+        List<List<String>> invOutR();
+    }
+
+    public interface Sub extends Super {
+        void outS(List<String> p);
+
+        void invOutS(List<List<String>> p);
+
+        void outOutS(List<List<String>> p);
+
+        List<String> outR();
+
+        List<String> invR();
+
+        List<List<String>> invOutR();
+    }
+}

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt

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

compiler/testData/loadJava/compiledJavaCompareWithKotlin/kotlinSignature/propagation/PropagateTypeArgumentNullable.txt

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface ChangeProjectionKind1 {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: MutableList<in String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Projection kind mismatch, actual: in, in alternative signature: ")
+        @KotlinSignature("fun foo(p: MutableList<String>)")
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait ChangeProjectionKind1: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: MutableList<in String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: MutableList<in String>)
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface ChangeProjectionKind2 {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: MutableList<String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Parameter type changed for method which overrides another: MutableList<in String>, was: MutableList<String>")
+        @KotlinSignature("fun foo(p: MutableList<in String>)")
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait ChangeProjectionKind2: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: MutableList<String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: MutableList<String>)
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface DeeplySubstitutedClassParameter {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(t: T)")
+        void foo(T p);
+    }
+
+    public interface Middle<E> extends Super<E> {
+        void foo(E p);
+    }
+
+    public interface Sub extends Middle<String> {
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,16 @@
+package test
+
+public trait DeeplySubstitutedClassParameter: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(p0: T)
+    }
+
+    public trait Middle<E>: Super<E> {
+        override fun foo(p0: E)
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface DeeplySubstitutedClassParameter2 {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(t: T)")
+        void foo(T p);
+    }
+
+    public interface Middle<E> extends Super<E> {
+    }
+
+    public interface Sub extends Middle<String> {
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,15 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(p0: T)
+    }
+
+    public trait Middle<E>: Super<E> {
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface InheritMutability {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: MutableList<String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritMutability: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: MutableList<String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: MutableList<String>)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritNotVararg {
+
+    public interface Super {
+        void foo(String[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String... p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVararg: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: Array<out String>?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out String>?)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritNotVarargInteger {
+
+    public interface Super {
+        void foo(Integer[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(Integer... p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVarargInteger: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: Array<out Int>?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out Int>?)
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface InheritNotVarargNotNull {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: Array<out String>)")
+        void foo(String[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String... p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVarargNotNull: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: Array<out String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out String>)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritNotVarargPrimitive {
+
+    public interface Super {
+        void foo(int[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(int... p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVarargPrimitive: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: IntArray?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: IntArray?)
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface InheritNullability {
+
+    public interface Super {
+        void foo(@NotNull String p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNullability: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: String)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface InheritProjectionKind {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: MutableList<in String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritProjectionKind: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: MutableList<in String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: MutableList<in String>)
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface InheritReadOnliness {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: List<String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritReadOnliness: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: List<String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: List<String>)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritVararg {
+
+    public interface Super {
+        void foo(String... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String[] p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVararg: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: String?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: String?)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritVarargInteger {
+
+    public interface Super {
+        void foo(Integer... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(Integer[] p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVarargInteger: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: Int?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int?)
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface InheritVarargNotNull {
+
+    public interface Super {
+        @KotlinSignature("fun foo(vararg p: String)")
+        void foo(String... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String[] p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVarargNotNull: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: String)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritVarargPrimitive {
+
+    public interface Super {
+        void foo(int... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(int[] p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVarargPrimitive: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: Int)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int)
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+// See SubclassFromGenericAndNot, as well
+public interface Kt3302 {
+    public interface BSONObject {
+        Object put(@NotNull String s, @NotNull Object o);
+    }
+
+    public interface LinkedHashMap<K, V> {
+        @KotlinSignature("fun put(key : K, value : V) : V?")
+        public V put(K key, V value);
+    }
+
+    public interface BasicBSONObject extends LinkedHashMap<String, Object>, BSONObject {
+        @Override
+        public Object put(String key, Object value);
+    }
+}

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

@@ -0,0 +1,16 @@
+package test
+
+// See SubclassFromGenericAndNot, as well
+public trait Kt3302: Object {
+    public trait BSONObject : Object {
+        public fun put(p0: String, p1: Any): Any?
+    }
+
+    public trait LinkedHashMap<K, V> : Object {
+        public fun put(p0: K, p1: V): V?
+    }
+
+    public trait BasicBSONObject : LinkedHashMap<String, Any>, BSONObject {
+        override fun put(p0: String, p1: Any): Any?
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface MutableToReadOnly {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: MutableList<String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Parameter type changed for method which overrides another: List<String>, was: MutableList<String>")
+        @KotlinSignature("fun foo(p: List<String>)")
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait MutableToReadOnly: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: MutableList<String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: MutableList<String>)
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface NotNullToNullable {
+
+    public interface Super {
+        void foo(@NotNull String p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.String' is not-null, while type in alternative signature is nullable: 'String?'")
+        @KotlinSignature("fun foo(p: String?)")
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait NotNullToNullable: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: String)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface NullableToNotNull {
+
+    public interface Super {
+        void foo(String p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("In superclass type is nullable: [String?], in subclass it is not: String")
+        void foo(@NotNull String p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait NullableToNotNull: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: String?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String?)
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface NullableToNotNullKotlinSignature {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: String?)")
+        void foo(String p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Parameter type changed for method which overrides another: String, was: String?")
+        @KotlinSignature("fun foo(p: String)")
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait NullableToNotNullKotlinSignature: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: String?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: String?)
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+package test;
+
+public interface OverrideWithErasedParameter  {
+
+    public interface Super<T> {
+        void foo(T t);
+    }
+
+    public interface Sub<T> extends Super<T> {
+        void foo(Object o);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait OverrideWithErasedParameter: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(p0: T?)
+    }
+
+    public trait Sub<T>: Super<T> {
+        override fun foo(p0: T?)
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+import java.util.*;
+
+public interface ReadOnlyToMutable {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: List<String>)")
+        void foo(List<String> p);
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Parameter type changed for method which overrides another: MutableList<String>, was: List<String>")
+        @KotlinSignature("fun foo(p: MutableList<String>)")
+        void foo(List<String> p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait ReadOnlyToMutable: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: List<String>)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: List<String>)
+    }
+}

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

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

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

@@ -0,0 +1,22 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+// Extracted from KT-3302, see Kt3302 test, as well
+public interface SubclassFromGenericAndNot {
+
+    public interface NonGeneric {
+        void foo(@NotNull String s);
+    }
+
+    public interface Generic<T> {
+        @KotlinSignature("fun foo(key : T)")
+        public void foo(T key);
+    }
+
+    public interface Sub extends NonGeneric, Generic<String> {
+        @Override
+        public void foo(String key);
+    }
+}

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

@@ -0,0 +1,17 @@
+package test
+
+// Extracted from KT-3302, see Kt3302 test, as well
+public trait SubclassFromGenericAndNot: Object {
+
+    public trait NonGeneric : Object {
+        public fun foo(p0: String)
+    }
+
+    public trait Generic<T> : Object {
+        public fun foo(p0: T)
+    }
+
+    public trait Sub : NonGeneric, Generic<String> {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface SubstitutedClassParameter {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(t: T)")
+        void foo(T p);
+    }
+
+    public interface Sub extends Super<String> {
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait SubstitutedClassParameter: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(p0: T)
+    }
+
+    public trait Sub: Super<String> {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface SubstitutedClassParameters {
+
+    public interface Super1<T> {
+        @KotlinSignature("fun foo(t: T)")
+        void foo(T p);
+    }
+
+    public interface Super2<E> {
+        @KotlinSignature("fun foo(t: E)")
+        void foo(E p);
+    }
+
+    public interface Sub extends Super1<String>, Super2<String> {
+        void foo(String p);
+    }
+}

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

@@ -0,0 +1,16 @@
+package test
+
+public trait SubstitutedClassParameters: Object {
+
+    public trait Super1<T>: Object {
+        public fun foo(p0: T)
+    }
+
+    public trait Super2<E>: Object {
+        public fun foo(p0: E)
+    }
+
+    public trait Sub: Super1<String>, Super2<String> {
+        override fun foo(p0: String)
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface AddNotNullJavaSubtype {
+
+    public interface Super {
+        CharSequence foo();
+    }
+
+    public interface Sub extends Super {
+        @NotNull
+        String foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNotNullJavaSubtype : Object {
+
+    public trait Super: Object {
+        public fun foo(): CharSequence?
+    }
+
+    public trait Sub: Super {
+        override fun foo(): String
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface AddNotNullSameJavaType {
+
+    public interface Super {
+        CharSequence foo();
+    }
+
+    public interface Sub extends Super {
+        @NotNull
+        CharSequence foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNotNullSameJavaType: Object {
+
+    public trait Super: Object {
+        public fun foo(): CharSequence?
+    }
+
+    public trait Sub: Super {
+        override fun foo(): CharSequence
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface AddNullabilityJavaSubtype {
+
+    public interface Super {
+        @NotNull
+        CharSequence foo();
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.String' is not-null, while type in alternative signature is nullable: 'String?'")
+        @KotlinSignature("fun foo(): String?")
+        String foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNullabilityJavaSubtype: Object {
+
+    public trait Super: Object {
+        public fun foo(): CharSequence
+    }
+
+    public trait Sub: Super {
+        override fun foo(): String
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface AddNullabilitySameGenericType1 {
+
+    public interface Super {
+        @KotlinSignature("fun foo(): MutableList<String>")
+        List<String> foo();
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Return type is changed to not subtype for method which overrides another: MutableList<String?>, was: MutableList<String>")
+        @KotlinSignature("fun foo(): MutableList<String?>")
+        List<String> foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNullabilitySameGenericType1: Object {
+
+    public trait Super: Object {
+        public fun foo(): MutableList<String>
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface AddNullabilitySameGenericType2 {
+
+    public interface Super {
+        @KotlinSignature("fun foo(): MutableList<String>")
+        List<String> foo();
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.MutableList<jet.String>' is not-null, while type in alternative signature is nullable: 'MutableList<String>?'")
+        @KotlinSignature("fun foo(): MutableList<String>?")
+        List<String> foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNullabilitySameGenericType2: Object {
+
+    public trait Super: Object {
+        public fun foo(): MutableList<String>
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableList<String>
+    }
+}

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

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

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

@@ -0,0 +1,20 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import java.lang.CharSequence;
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface AddNullabilitySameJavaType {
+
+    public interface Super {
+        @NotNull
+        CharSequence foo();
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Auto type 'jet.CharSequence' is not-null, while type in alternative signature is nullable: 'CharSequence?'")
+        @KotlinSignature("fun foo(): CharSequence?")
+        CharSequence foo();
+    }
+}

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

@@ -0,0 +1,12 @@
+package test
+
+public trait AddNullabilitySameJavaType: Object {
+
+    public trait Super: Object {
+        public fun foo(): CharSequence
+    }
+
+    public trait Sub: Super {
+        override fun foo(): CharSequence
+    }
+}

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

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

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

@@ -0,0 +1,21 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import java.util.*;
+
+import jet.runtime.typeinfo.KotlinSignature;
+import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError;
+
+public interface CantMakeImmutableInSubclass {
+
+    public interface Super {
+        @KotlinSignature("fun foo(): MutableCollection<String>")
+        Collection<String> foo();
+    }
+
+    public interface Sub extends Super {
+        @ExpectLoadError("Return type is changed to not subtype for method which overrides another: List<String>, was: MutableList<String>")
+        @KotlinSignature("fun foo(): List<String>")
+        List<String> foo();
+    }
+}