From 059c6d0673891dfd3f9807570413b2ec448f6b9a Mon Sep 17 00:00:00 2001
From: Evgeny Gerashchenko <Evgeny.Gerashchenko@jetbrains.com>
Date: Mon, 19 Nov 2012 14:00:18 +0400
Subject: [PATCH] Added tests for signatures propagation.

---
 .../return/HalfSubstitutedTypeParameters.java | 19 +++++++++
 .../return/HalfSubstitutedTypeParameters.kt   | 14 +++++++
 .../return/HalfSubstitutedTypeParameters.txt  | 35 ++++++++++++++++
 .../return/SameProjectionKind.java            | 18 +++++++++
 .../propagation/return/SameProjectionKind.kt  | 12 ++++++
 .../propagation/return/SameProjectionKind.txt | 10 +++++
 ...uperclassesConflictingProjectionKinds.java | 23 +++++++++++
 ...oSuperclassesConflictingProjectionKinds.kt | 16 ++++++++
 ...SuperclassesConflictingProjectionKinds.txt | 13 ++++++
 .../return/TwoSuperclassesMutableAndNot.java  | 22 ++++++++++
 .../return/TwoSuperclassesMutableAndNot.kt    | 16 ++++++++
 .../return/TwoSuperclassesMutableAndNot.txt   | 13 ++++++
 .../TwoSuperclassesSupplementNotNull.java     | 23 +++++++++++
 .../TwoSuperclassesSupplementNotNull.kt       | 16 ++++++++
 .../TwoSuperclassesSupplementNotNull.txt      | 13 ++++++
 .../propagation/return/TypeParamOfClass.java  | 17 ++++++++
 .../propagation/return/TypeParamOfClass.kt    | 12 ++++++
 .../propagation/return/TypeParamOfClass.txt   | 10 +++++
 .../return/TypeParamOfClassSubstituted.java   | 17 ++++++++
 .../return/TypeParamOfClassSubstituted.kt     | 12 ++++++
 .../return/TypeParamOfClassSubstituted.txt    | 10 +++++
 .../propagation/return/TypeParamOfFun.java    | 17 ++++++++
 .../propagation/return/TypeParamOfFun.kt      | 12 ++++++
 .../propagation/return/TypeParamOfFun.txt     | 10 +++++
 .../jvm/compiler/LoadJavaTestGenerated.java   | 40 +++++++++++++++++++
 ...esolveNamespaceComparingTestGenerated.java | 40 +++++++++++++++++++
 26 files changed, 460 insertions(+)
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.txt

diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java
new file mode 100644
index 00000000000..4fd69a9c1af
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java
@@ -0,0 +1,19 @@
+package test;
+
+import java.util.*;
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface HalfSubstitutedTypeParameters {
+
+    public interface TrickyList<X, E> extends List<E> {}
+
+    public interface Super {
+        @KotlinSignature("fun foo(): MutableList<String>")
+        List<String> foo();
+    }
+
+    public interface Sub extends Super {
+        TrickyList<Integer, String> foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt
new file mode 100644
index 00000000000..21853229e97
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt
@@ -0,0 +1,14 @@
+package test
+
+public trait HalfSubstitutedTypeParameters: Object {
+
+    public trait TrickyList<X, E>: MutableList<E> {}
+
+    public trait Super: Object {
+        public fun foo(): MutableList<String>
+    }
+
+    public trait Sub: Super {
+        override fun foo(): TrickyList<Int?, String>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt
new file mode 100644
index 00000000000..8fff27422fb
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.txt
@@ -0,0 +1,35 @@
+namespace test
+
+public abstract trait test.HalfSubstitutedTypeParameters : java.lang.Object {
+    public abstract trait test.HalfSubstitutedTypeParameters.Sub : test.HalfSubstitutedTypeParameters.Super {
+        public abstract override /*1*/ fun foo(): test.HalfSubstitutedTypeParameters.TrickyList<jet.Int?, jet.String>
+    }
+    public abstract trait test.HalfSubstitutedTypeParameters.Super : java.lang.Object {
+        public abstract fun foo(): jet.MutableList<jet.String>
+    }
+    public abstract trait test.HalfSubstitutedTypeParameters.TrickyList</*0*/ X : jet.Any?, /*1*/ E : jet.Any?> : jet.MutableList<E> {
+        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ e: E): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index: jet.Int, /*1*/ element: E): jet.Tuple0
+        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ c: jet.Collection<out E>): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: jet.Int, /*1*/ c: jet.Collection<out E>): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun clear(): jet.Tuple0
+        public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o: jet.Any?): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: jet.Int): E
+        public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o: jet.Any?): jet.Int
+        public abstract override /*1*/ /*fake_override*/ fun isEmpty(): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun iterator(): jet.Iterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o: jet.Any?): jet.Int
+        public abstract override /*1*/ /*fake_override*/ fun listIterator(): jet.MutableListIterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: jet.Int): jet.MutableListIterator<E>
+        public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ index: jet.Int): E
+        public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ o: jet.Any?): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ c: jet.Collection<out jet.Any?>): jet.Boolean
+        public abstract override /*1*/ /*fake_override*/ fun set(/*0*/ index: jet.Int, /*1*/ element: E): E
+        public abstract override /*1*/ /*fake_override*/ fun size(): jet.Int
+        public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.MutableList<E>
+        public abstract override /*1*/ /*fake_override*/ fun toArray(): jet.Array<jet.Any?>
+        public abstract override /*1*/ /*fake_override*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ a: jet.Array<out T>): jet.Array<T>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java
new file mode 100644
index 00000000000..5993d20b248
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java
@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+import java.util.Collection;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface SameProjectionKind {
+
+    public interface Super {
+        Collection<? extends Number> foo();
+    }
+
+    public interface Sub extends Super {
+        Collection<? extends Number> foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt
new file mode 100644
index 00000000000..5609ebd7850
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt
@@ -0,0 +1,12 @@
+package test
+
+public trait SameProjectionKind: Object {
+
+    public trait Super: Object {
+        public fun foo(): MutableCollection<out Number?>?
+    }
+
+    public trait Sub: Super {
+        override fun foo(): MutableCollection<out Number?>?
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.txt
new file mode 100644
index 00000000000..8b798bc2373
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.txt
@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.SameProjectionKind : java.lang.Object {
+    public abstract trait test.SameProjectionKind.Sub : test.SameProjectionKind.Super {
+        public abstract override /*1*/ fun foo(): jet.MutableCollection<out jet.Number?>?
+    }
+    public abstract trait test.SameProjectionKind.Super : java.lang.Object {
+        public abstract fun foo(): jet.MutableCollection<out jet.Number?>?
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
new file mode 100644
index 00000000000..c0bbc51a85d
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java
@@ -0,0 +1,23 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.util.*;
+
+public interface TwoSuperclassesConflictingProjectionKinds {
+
+    public interface Super1 {
+        @KotlinSignature("fun foo(): MutableCollection<CharSequence>")
+        public Collection<CharSequence> foo();
+    }
+
+    public interface Super2 {
+        @KotlinSignature("fun foo(): MutableCollection<out CharSequence>")
+        public Collection<CharSequence> foo();
+    }
+
+    public interface Sub extends Super1, Super2 {
+        public Collection<CharSequence> foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt
new file mode 100644
index 00000000000..8a285d03d3e
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait TwoSuperclassesConflictingProjectionKinds: Object {
+
+    public trait Super1: Object {
+        public fun foo(): MutableCollection<CharSequence>
+    }
+
+    public trait Super2: Object {
+        public fun foo(): MutableCollection<out CharSequence>
+    }
+
+    public trait Sub: Super1, Super2 {
+        override fun foo(): MutableCollection<CharSequence>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt
new file mode 100644
index 00000000000..e3057b3c40f
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.txt
@@ -0,0 +1,13 @@
+namespace test
+
+public abstract trait test.TwoSuperclassesConflictingProjectionKinds : java.lang.Object {
+    public abstract trait test.TwoSuperclassesConflictingProjectionKinds.Sub : test.TwoSuperclassesConflictingProjectionKinds.Super1, test.TwoSuperclassesConflictingProjectionKinds.Super2 {
+        public abstract override /*2*/ fun foo(): jet.MutableCollection<jet.CharSequence>
+    }
+    public abstract trait test.TwoSuperclassesConflictingProjectionKinds.Super1 : java.lang.Object {
+        public abstract fun foo(): jet.MutableCollection<jet.CharSequence>
+    }
+    public abstract trait test.TwoSuperclassesConflictingProjectionKinds.Super2 : java.lang.Object {
+        public abstract fun foo(): jet.MutableCollection<out jet.CharSequence>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java
new file mode 100644
index 00000000000..a46815a4603
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java
@@ -0,0 +1,22 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import java.util.*;
+
+public interface TwoSuperclassesMutableAndNot {
+
+    public interface Super1 {
+        @KotlinSignature("fun foo(): MutableCollection<String>")
+        public Collection<String> foo();
+    }
+
+    public interface Super2 {
+        @KotlinSignature("fun foo(): List<String>")
+        public List<String> foo();
+    }
+
+    public interface Sub extends Super1, Super2 {
+        public List<String> foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt
new file mode 100644
index 00000000000..8f3cee4577f
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait TwoSuperclassesMutableAndNot: Object {
+
+    public trait Super1: Object {
+        public fun foo(): MutableCollection<String>
+    }
+
+    public trait Super2: Object {
+        public fun foo(): List<String>
+    }
+
+    public trait Sub: Super1, Super2 {
+        override fun foo(): MutableList<String>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt
new file mode 100644
index 00000000000..49b9d282e91
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.txt
@@ -0,0 +1,13 @@
+namespace test
+
+public abstract trait test.TwoSuperclassesMutableAndNot : java.lang.Object {
+    public abstract trait test.TwoSuperclassesMutableAndNot.Sub : test.TwoSuperclassesMutableAndNot.Super1, test.TwoSuperclassesMutableAndNot.Super2 {
+        public abstract override /*2*/ fun foo(): jet.MutableList<jet.String>
+    }
+    public abstract trait test.TwoSuperclassesMutableAndNot.Super1 : java.lang.Object {
+        public abstract fun foo(): jet.MutableCollection<jet.String>
+    }
+    public abstract trait test.TwoSuperclassesMutableAndNot.Super2 : java.lang.Object {
+        public abstract fun foo(): jet.List<jet.String>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java
new file mode 100644
index 00000000000..3b471b09761
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java
@@ -0,0 +1,23 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import java.util.*;
+import jet.*;
+
+public interface TwoSuperclassesSupplementNotNull {
+
+    public interface Super1 {
+        @KotlinSignature("fun foo(): Function0<String?>")
+        public Function0<String> foo();
+    }
+
+    public interface Super2 {
+        @KotlinSignature("fun foo(): Function0<String>?")
+        public Function0<String> foo();
+    }
+
+    public interface Sub extends Super1, Super2 {
+        public Function0<String> foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt
new file mode 100644
index 00000000000..125fb2d740f
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait TwoSuperclassesSupplementNotNull: Object {
+
+    public trait Super1: Object {
+        public fun foo(): Function0<String?>
+    }
+
+    public trait Super2: Object {
+        public fun foo(): Function0<String>?
+    }
+
+    public trait Sub: Super1, Super2 {
+        override fun foo(): Function0<String>
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt
new file mode 100644
index 00000000000..436c40cbcc1
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.txt
@@ -0,0 +1,13 @@
+namespace test
+
+public abstract trait test.TwoSuperclassesSupplementNotNull : java.lang.Object {
+    public abstract trait test.TwoSuperclassesSupplementNotNull.Sub : test.TwoSuperclassesSupplementNotNull.Super1, test.TwoSuperclassesSupplementNotNull.Super2 {
+        public abstract override /*2*/ fun foo(): jet.Function0<jet.String>
+    }
+    public abstract trait test.TwoSuperclassesSupplementNotNull.Super1 : java.lang.Object {
+        public abstract fun foo(): jet.Function0<jet.String?>
+    }
+    public abstract trait test.TwoSuperclassesSupplementNotNull.Super2 : java.lang.Object {
+        public abstract fun foo(): jet.Function0<jet.String>?
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.java
new file mode 100644
index 00000000000..ac84c82de7a
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.java
@@ -0,0 +1,17 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import java.util.*;
+
+public interface TypeParamOfClass {
+
+    public interface Super<T> {
+        @NotNull
+        public T foo();
+    }
+
+    public interface Sub<T> extends Super<T> {
+        public T foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt
new file mode 100644
index 00000000000..2db00d87c36
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt
@@ -0,0 +1,12 @@
+package test
+
+public trait TypeParamOfClass: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Sub<T>: Super<T> {
+        override fun foo(): T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
new file mode 100644
index 00000000000..dc59f4bc3da
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.txt
@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.TypeParamOfClass : java.lang.Object {
+    public abstract trait test.TypeParamOfClass.Sub</*0*/ T : jet.Any?> : test.TypeParamOfClass.Super<T> {
+        public abstract override /*1*/ fun foo(): T
+    }
+    public abstract trait test.TypeParamOfClass.Super</*0*/ T : jet.Any?> : java.lang.Object {
+        public abstract fun foo(): T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java
new file mode 100644
index 00000000000..e67ff324d04
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java
@@ -0,0 +1,17 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import java.util.*;
+
+public interface TypeParamOfClassSubstituted {
+
+    public interface Super<T> {
+        @NotNull
+        public T foo();
+    }
+
+    public interface Sub extends Super<String> {
+        public String foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt
new file mode 100644
index 00000000000..66c25ccbd0d
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt
@@ -0,0 +1,12 @@
+package test
+
+public trait TypeParamOfClassSubstituted: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Sub: Super<String> {
+        override fun foo(): String
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
new file mode 100644
index 00000000000..7e9ad34b02f
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt
@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.TypeParamOfClassSubstituted : java.lang.Object {
+    public abstract trait test.TypeParamOfClassSubstituted.Sub : test.TypeParamOfClassSubstituted.Super<jet.String> {
+        public abstract override /*1*/ fun foo(): jet.String
+    }
+    public abstract trait test.TypeParamOfClassSubstituted.Super</*0*/ T : jet.Any?> : java.lang.Object {
+        public abstract fun foo(): T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.java
new file mode 100644
index 00000000000..672a52c0443
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.java
@@ -0,0 +1,17 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+import java.util.*;
+
+public interface TypeParamOfFun {
+
+    public interface Super {
+        @NotNull
+        public <T> T foo();
+    }
+
+    public interface Sub extends Super {
+        public <E> E foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt
new file mode 100644
index 00000000000..9fa963b68c5
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt
@@ -0,0 +1,12 @@
+package test
+
+public trait TypeParamOfFun: Object {
+
+    public trait Super: Object {
+        public fun <T> foo(): T
+    }
+
+    public trait Sub: Super {
+        override fun <E> foo(): E
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.txt
new file mode 100644
index 00000000000..ac8a22fc045
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.txt
@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.TypeParamOfFun : java.lang.Object {
+    public abstract trait test.TypeParamOfFun.Sub : test.TypeParamOfFun.Super {
+        public abstract override /*1*/ fun </*0*/ E : jet.Any?>foo(): E
+    }
+    public abstract trait test.TypeParamOfFun.Super : java.lang.Object {
+        public abstract fun </*0*/ T : jet.Any?>foo(): T
+    }
+}
diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
index 3afc7617747..0d335c6bb46 100644
--- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
@@ -481,6 +481,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation/return"), "java", true);
                 }
                 
+                @TestMetadata("HalfSubstitutedTypeParameters.java")
+                public void testHalfSubstitutedTypeParameters() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java");
+                }
+                
                 @TestMetadata("InheritNullabilityGenericSubclassSimple.java")
                 public void testInheritNullabilityGenericSubclassSimple() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java");
@@ -521,6 +526,21 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritVariance.java");
                 }
                 
+                @TestMetadata("SameProjectionKind.java")
+                public void testSameProjectionKind() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java");
+                }
+                
+                @TestMetadata("TwoSuperclassesConflictingProjectionKinds.java")
+                public void testTwoSuperclassesConflictingProjectionKinds() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java");
+                }
+                
+                @TestMetadata("TwoSuperclassesMutableAndNot.java")
+                public void testTwoSuperclassesMutableAndNot() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java");
+                }
+                
                 @TestMetadata("TwoSuperclassesReturnJavaSubtype.java")
                 public void testTwoSuperclassesReturnJavaSubtype() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java");
@@ -531,6 +551,26 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java");
                 }
                 
+                @TestMetadata("TwoSuperclassesSupplementNotNull.java")
+                public void testTwoSuperclassesSupplementNotNull() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java");
+                }
+                
+                @TestMetadata("TypeParamOfClass.java")
+                public void testTypeParamOfClass() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.java");
+                }
+                
+                @TestMetadata("TypeParamOfClassSubstituted.java")
+                public void testTypeParamOfClassSubstituted() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java");
+                }
+                
+                @TestMetadata("TypeParamOfFun.java")
+                public void testTypeParamOfFun() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.java");
+                }
+                
             }
             
             public static Test innerSuite() {
diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
index 3c36fc78af9..7e67673b659 100644
--- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
@@ -1391,6 +1391,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation/return"), "kt", true);
                     }
                     
+                    @TestMetadata("HalfSubstitutedTypeParameters.kt")
+                    public void testHalfSubstitutedTypeParameters() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt");
+                    }
+                    
                     @TestMetadata("InheritNullabilityGenericSubclassSimple.kt")
                     public void testInheritNullabilityGenericSubclassSimple() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt");
@@ -1431,6 +1436,21 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritVariance.kt");
                     }
                     
+                    @TestMetadata("SameProjectionKind.kt")
+                    public void testSameProjectionKind() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt");
+                    }
+                    
+                    @TestMetadata("TwoSuperclassesConflictingProjectionKinds.kt")
+                    public void testTwoSuperclassesConflictingProjectionKinds() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt");
+                    }
+                    
+                    @TestMetadata("TwoSuperclassesMutableAndNot.kt")
+                    public void testTwoSuperclassesMutableAndNot() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt");
+                    }
+                    
                     @TestMetadata("TwoSuperclassesReturnJavaSubtype.kt")
                     public void testTwoSuperclassesReturnJavaSubtype() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt");
@@ -1441,6 +1461,26 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt");
                     }
                     
+                    @TestMetadata("TwoSuperclassesSupplementNotNull.kt")
+                    public void testTwoSuperclassesSupplementNotNull() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt");
+                    }
+                    
+                    @TestMetadata("TypeParamOfClass.kt")
+                    public void testTypeParamOfClass() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt");
+                    }
+                    
+                    @TestMetadata("TypeParamOfClassSubstituted.kt")
+                    public void testTypeParamOfClassSubstituted() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt");
+                    }
+                    
+                    @TestMetadata("TypeParamOfFun.kt")
+                    public void testTypeParamOfFun() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt");
+                    }
+                    
                 }
                 
                 public static Test innerSuite() {