From 74771cb2db9519b741c09c5a524cdccc2f1afebb Mon Sep 17 00:00:00 2001
From: Evgeny Gerashchenko <Evgeny.Gerashchenko@jetbrains.com>
Date: Thu, 31 Jan 2013 18:57:40 +0400
Subject: [PATCH] KT-3302 Method that implements two differing interfaces are
 reported as "Incompatible types in superclasses"

 #KT-3302 fixed
---
 .../SignaturesPropagationData.java            | 27 ++++++++-
 .../DeeplySubstitutedClassParameter.java      | 20 +++++++
 .../DeeplySubstitutedClassParameter.kt        | 16 ++++++
 .../DeeplySubstitutedClassParameter.txt       | 16 ++++++
 .../DeeplySubstitutedClassParameter2.java     | 19 +++++++
 .../DeeplySubstitutedClassParameter2.kt       | 15 +++++
 .../DeeplySubstitutedClassParameter2.txt      | 16 ++++++
 .../propagation/parameter/Kt3302.java         | 21 +++++++
 .../propagation/parameter/Kt3302.kt           | 16 ++++++
 .../propagation/parameter/Kt3302.txt          | 16 ++++++
 .../parameter/SubclassFromGenericAndNot.java  | 22 ++++++++
 .../parameter/SubclassFromGenericAndNot.kt    | 17 ++++++
 .../parameter/SubclassFromGenericAndNot.txt   | 16 ++++++
 .../parameter/SubstitutedClassParameter.java  | 16 ++++++
 .../parameter/SubstitutedClassParameter.kt    | 12 ++++
 .../parameter/SubstitutedClassParameter.txt   | 12 ++++
 .../parameter/SubstitutedClassParameters.java | 21 +++++++
 .../parameter/SubstitutedClassParameters.kt   | 16 ++++++
 .../parameter/SubstitutedClassParameters.txt  | 16 ++++++
 .../DeeplySubstitutedClassParameter.java      | 22 ++++++++
 .../return/DeeplySubstitutedClassParameter.kt | 16 ++++++
 .../DeeplySubstitutedClassParameter.txt       | 16 ++++++
 .../DeeplySubstitutedClassParameter2.java     | 21 +++++++
 .../DeeplySubstitutedClassParameter2.kt       | 15 +++++
 .../DeeplySubstitutedClassParameter2.txt      | 16 ++++++
 .../return/SubclassFromGenericAndNot.java     | 21 +++++++
 .../return/SubclassFromGenericAndNot.kt       | 16 ++++++
 .../return/SubclassFromGenericAndNot.txt      | 16 ++++++
 .../return/SubstitutedClassParameter.java     | 18 ++++++
 .../return/SubstitutedClassParameter.kt       | 12 ++++
 .../return/SubstitutedClassParameter.txt      | 12 ++++
 .../return/SubstitutedClassParameters.java    | 23 ++++++++
 .../return/SubstitutedClassParameters.kt      | 16 ++++++
 .../return/SubstitutedClassParameters.txt     | 16 ++++++
 .../jvm/compiler/LoadJavaTestGenerated.java   | 55 +++++++++++++++++++
 ...esolveNamespaceComparingTestGenerated.java | 55 +++++++++++++++++++
 36 files changed, 695 insertions(+), 1 deletion(-)
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.txt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt
 create mode 100644 compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.txt

diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
index 0c1889afece..98e5c111f23 100644
--- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
+++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java
@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.java.kotlinSignature;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.intellij.openapi.application.ApplicationManager;
@@ -200,6 +201,9 @@ public class SignaturesPropagationData {
             @NotNull ClassDescriptor containingClass
     ) {
         List<FunctionDescriptor> superFunctions = Lists.newArrayList();
+
+        Map<ClassDescriptor, JetType> superclassToSupertype = getSuperclassToSupertypeMap(containingClass);
+
         for (HierarchicalMethodSignature superSignature : method.getPsiMethod().getHierarchicalMethodSignature().getSuperSignatures()) {
             PsiMethod superMethod = superSignature.getMethod();
 
@@ -222,7 +226,18 @@ public class SignaturesPropagationData {
             }
 
             assert superFun instanceof FunctionDescriptor : superFun.getClass().getName();
-            superFunctions.add((FunctionDescriptor) superFun);
+
+            DeclarationDescriptor superFunContainer = superFun.getContainingDeclaration();
+            assert superFunContainer instanceof ClassDescriptor: superFunContainer;
+
+            JetType supertype = superclassToSupertype.get(superFunContainer);
+            assert supertype != null : "Couldn't find super type for super function: " + superFun;
+            TypeSubstitutor supertypeSubstitutor = TypeSubstitutor.create(supertype);
+
+            FunctionDescriptor substitutedSuperFun = ((FunctionDescriptor) superFun).substitute(supertypeSubstitutor);
+            assert substitutedSuperFun != null;
+
+            superFunctions.add(substitutedSuperFun);
         }
 
         // sorting for diagnostic stability
@@ -560,6 +575,16 @@ public class SignaturesPropagationData {
         return classifier;
     }
 
+    private static Map<ClassDescriptor, JetType> getSuperclassToSupertypeMap(ClassDescriptor containingClass) {
+        Map<ClassDescriptor, JetType> superclassToSupertype = Maps.newHashMap();
+        for (JetType supertype : TypeUtils.getAllSupertypes(containingClass.getDefaultType())) {
+            ClassifierDescriptor superclass = supertype.getConstructor().getDeclarationDescriptor();
+            assert superclass instanceof ClassDescriptor;
+            superclassToSupertype.put((ClassDescriptor) superclass, supertype);
+        }
+        return superclassToSupertype;
+    }
+
     private static boolean isArrayType(@NotNull JetType type) {
         KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
         return builtIns.isArray(type) || builtIns.isPrimitiveArray(type);
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java
new file mode 100644
index 00000000000..6119482ff6e
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt
new file mode 100644
index 00000000000..f0f602bb4df
--- /dev/null
+++ b/compiler/testData/loadJava/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)
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.txt
new file mode 100644
index 00000000000..0718e6aa75e
--- /dev/null
+++ b/compiler/testData/loadJava/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
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java
new file mode 100644
index 00000000000..5078f2e3272
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt
new file mode 100644
index 00000000000..25a53202837
--- /dev/null
+++ b/compiler/testData/loadJava/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)
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.txt
new file mode 100644
index 00000000000..2be57177a33
--- /dev/null
+++ b/compiler/testData/loadJava/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
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.java
new file mode 100644
index 00000000000..5e289de4f82
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.kt
new file mode 100644
index 00000000000..d868be41dcc
--- /dev/null
+++ b/compiler/testData/loadJava/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?
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.txt
new file mode 100644
index 00000000000..cadcfa9e6e1
--- /dev/null
+++ b/compiler/testData/loadJava/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?
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java
new file mode 100644
index 00000000000..b9ef46b8dba
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt
new file mode 100644
index 00000000000..b6cfc49b4f1
--- /dev/null
+++ b/compiler/testData/loadJava/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)
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.txt
new file mode 100644
index 00000000000..a59565a9354
--- /dev/null
+++ b/compiler/testData/loadJava/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
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java
new file mode 100644
index 00000000000..87c3efd4e13
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt
new file mode 100644
index 00000000000..24932e12ad9
--- /dev/null
+++ b/compiler/testData/loadJava/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)
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.txt
new file mode 100644
index 00000000000..412baafb381
--- /dev/null
+++ b/compiler/testData/loadJava/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
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java
new file mode 100644
index 00000000000..8b85e4a6643
--- /dev/null
+++ b/compiler/testData/loadJava/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);
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt
new file mode 100644
index 00000000000..44b5acf7fc9
--- /dev/null
+++ b/compiler/testData/loadJava/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)
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.txt
new file mode 100644
index 00000000000..f3bc4567592
--- /dev/null
+++ b/compiler/testData/loadJava/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
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java
new file mode 100644
index 00000000000..690d49bfc53
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java
@@ -0,0 +1,22 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.lang.String;
+
+public interface DeeplySubstitutedClassParameter {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(): T")
+        T foo();
+    }
+
+    public interface Middle<E> extends Super<E> {
+        E foo();
+    }
+
+    public interface Sub extends Middle<String> {
+        String foo();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt
new file mode 100644
index 00000000000..30001ac557a
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait DeeplySubstitutedClassParameter: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Middle<E>: Super<E> {
+        override fun foo(): E
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(): String
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.txt
new file mode 100644
index 00000000000..8bf26d5c7c0
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/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() : E
+    }
+    
+    public trait Sub : test.DeeplySubstitutedClassParameter.Middle<jet.String> {
+        public abstract override /*1*/ fun foo() : jet.String
+    }
+    
+    public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun foo() : T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java
new file mode 100644
index 00000000000..ed7b7716ee6
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java
@@ -0,0 +1,21 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.lang.String;
+
+public interface DeeplySubstitutedClassParameter2 {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(): T")
+        T foo();
+    }
+
+    public interface Middle<E> extends Super<E> {
+    }
+
+    public interface Sub extends Middle<String> {
+        String foo();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt
new file mode 100644
index 00000000000..63be8d2e778
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt
@@ -0,0 +1,15 @@
+package test
+
+public trait DeeplySubstitutedClassParameter2: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Middle<E>: Super<E> {
+    }
+
+    public trait Sub: Middle<String> {
+        override fun foo(): String
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.txt
new file mode 100644
index 00000000000..bb4c79688db
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/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() : E
+    }
+    
+    public trait Sub : test.DeeplySubstitutedClassParameter2.Middle<jet.String> {
+        public abstract override /*1*/ fun foo() : jet.String
+    }
+    
+    public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun foo() : T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java
new file mode 100644
index 00000000000..fde78916a41
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java
@@ -0,0 +1,21 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface SubclassFromGenericAndNot {
+
+    public interface NonGeneric {
+        String foo();
+    }
+
+    public interface Generic<T> {
+        @KotlinSignature("fun foo(): T")
+        public T foo();
+    }
+
+    public interface Sub extends NonGeneric, Generic<String> {
+        @Override
+        public String foo();
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt
new file mode 100644
index 00000000000..bce5804a0a9
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait SubclassFromGenericAndNot: Object {
+
+    public trait NonGeneric : Object {
+        public fun foo(): String?
+    }
+
+    public trait Generic<T> : Object {
+        public fun foo(): T
+    }
+
+    public trait Sub : NonGeneric, Generic<String> {
+        override fun foo(): String
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.txt
new file mode 100644
index 00000000000..83c5f4fd21d
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/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() : T
+    }
+    
+    public trait NonGeneric : java.lang.Object {
+        public abstract fun foo() : jet.String?
+    }
+    
+    public trait Sub : test.SubclassFromGenericAndNot.NonGeneric, test.SubclassFromGenericAndNot.Generic<jet.String> {
+        public abstract override /*2*/ fun foo() : jet.String
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java
new file mode 100644
index 00000000000..ae0a9ff2243
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java
@@ -0,0 +1,18 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.lang.String;
+
+public interface SubstitutedClassParameter {
+
+    public interface Super<T> {
+        @KotlinSignature("fun foo(): T")
+        T foo();
+    }
+
+    public interface Sub extends Super<String> {
+        String foo();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt
new file mode 100644
index 00000000000..ddf6daf1088
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt
@@ -0,0 +1,12 @@
+package test
+
+public trait SubstitutedClassParameter: Object {
+
+    public trait Super<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Sub: Super<String> {
+        override fun foo(): String
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.txt
new file mode 100644
index 00000000000..9e3d2765a8f
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/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() : jet.String
+    }
+    
+    public trait Super</*0*/ T> : java.lang.Object {
+        public abstract fun foo() : T
+    }
+}
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java
new file mode 100644
index 00000000000..97ab7fbdd48
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java
@@ -0,0 +1,23 @@
+package test;
+
+import org.jetbrains.annotations.NotNull;
+import jet.runtime.typeinfo.KotlinSignature;
+
+import java.lang.String;
+
+public interface SubstitutedClassParameters {
+
+    public interface Super1<T> {
+        @KotlinSignature("fun foo(): T")
+        T foo();
+    }
+
+    public interface Super2<E> {
+        @KotlinSignature("fun foo(): E")
+        E foo();
+    }
+
+    public interface Sub extends Super1<String>, Super2<String> {
+        String foo();
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt
new file mode 100644
index 00000000000..b2de7bb2fc1
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt
@@ -0,0 +1,16 @@
+package test
+
+public trait SubstitutedClassParameters: Object {
+
+    public trait Super1<T>: Object {
+        public fun foo(): T
+    }
+
+    public trait Super2<E>: Object {
+        public fun foo(): E
+    }
+
+    public trait Sub: Super1<String>, Super2<String> {
+        override fun foo(): String
+    }
+}
\ No newline at end of file
diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.txt
new file mode 100644
index 00000000000..101723954e1
--- /dev/null
+++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/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() : jet.String
+    }
+    
+    public trait Super1</*0*/ T> : java.lang.Object {
+        public abstract fun foo() : T
+    }
+    
+    public trait Super2</*0*/ E> : java.lang.Object {
+        public abstract fun foo() : E
+    }
+}
diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
index ce657dcb3d0..06e932d9858 100644
--- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java
@@ -493,6 +493,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.java");
                 }
                 
+                @TestMetadata("DeeplySubstitutedClassParameter.java")
+                public void testDeeplySubstitutedClassParameter() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java");
+                }
+                
+                @TestMetadata("DeeplySubstitutedClassParameter2.java")
+                public void testDeeplySubstitutedClassParameter2() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java");
+                }
+                
                 @TestMetadata("InheritMutability.java")
                 public void testInheritMutability() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritMutability.java");
@@ -553,6 +563,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java");
                 }
                 
+                @TestMetadata("Kt3302.java")
+                public void testKt3302() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.java");
+                }
+                
                 @TestMetadata("MutableToReadOnly.java")
                 public void testMutableToReadOnly() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.java");
@@ -578,6 +593,21 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java");
                 }
                 
+                @TestMetadata("SubclassFromGenericAndNot.java")
+                public void testSubclassFromGenericAndNot() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java");
+                }
+                
+                @TestMetadata("SubstitutedClassParameter.java")
+                public void testSubstitutedClassParameter() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java");
+                }
+                
+                @TestMetadata("SubstitutedClassParameters.java")
+                public void testSubstitutedClassParameters() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java");
+                }
+                
             }
             
             @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation/return")
@@ -621,6 +651,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java");
                 }
                 
+                @TestMetadata("DeeplySubstitutedClassParameter.java")
+                public void testDeeplySubstitutedClassParameter() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java");
+                }
+                
+                @TestMetadata("DeeplySubstitutedClassParameter2.java")
+                public void testDeeplySubstitutedClassParameter2() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java");
+                }
+                
                 @TestMetadata("HalfSubstitutedTypeParameters.java")
                 public void testHalfSubstitutedTypeParameters() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java");
@@ -671,6 +711,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.java");
                 }
                 
+                @TestMetadata("SubclassFromGenericAndNot.java")
+                public void testSubclassFromGenericAndNot() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java");
+                }
+                
                 @TestMetadata("SubclassOfCollection.java")
                 public void testSubclassOfCollection() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassOfCollection.java");
@@ -681,6 +726,16 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.java");
                 }
                 
+                @TestMetadata("SubstitutedClassParameter.java")
+                public void testSubstitutedClassParameter() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java");
+                }
+                
+                @TestMetadata("SubstitutedClassParameters.java")
+                public void testSubstitutedClassParameters() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java");
+                }
+                
                 @TestMetadata("TwoSuperclassesConflictingProjectionKinds.java")
                 public void testTwoSuperclassesConflictingProjectionKinds() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java");
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 2e8ed9782d3..9ecee061917 100644
--- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
@@ -1428,6 +1428,16 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt");
                     }
                     
+                    @TestMetadata("DeeplySubstitutedClassParameter.kt")
+                    public void testDeeplySubstitutedClassParameter() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt");
+                    }
+                    
+                    @TestMetadata("DeeplySubstitutedClassParameter2.kt")
+                    public void testDeeplySubstitutedClassParameter2() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt");
+                    }
+                    
                     @TestMetadata("InheritMutability.kt")
                     public void testInheritMutability() throws Exception {
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritMutability.kt");
@@ -1488,6 +1498,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt");
                     }
                     
+                    @TestMetadata("Kt3302.kt")
+                    public void testKt3302() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/Kt3302.kt");
+                    }
+                    
                     @TestMetadata("MutableToReadOnly.kt")
                     public void testMutableToReadOnly() throws Exception {
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.kt");
@@ -1513,6 +1528,21 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt");
                     }
                     
+                    @TestMetadata("SubclassFromGenericAndNot.kt")
+                    public void testSubclassFromGenericAndNot() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt");
+                    }
+                    
+                    @TestMetadata("SubstitutedClassParameter.kt")
+                    public void testSubstitutedClassParameter() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt");
+                    }
+                    
+                    @TestMetadata("SubstitutedClassParameters.kt")
+                    public void testSubstitutedClassParameters() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt");
+                    }
+                    
                 }
                 
                 @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation/return")
@@ -1556,6 +1586,16 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt");
                     }
                     
+                    @TestMetadata("DeeplySubstitutedClassParameter.kt")
+                    public void testDeeplySubstitutedClassParameter() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt");
+                    }
+                    
+                    @TestMetadata("DeeplySubstitutedClassParameter2.kt")
+                    public void testDeeplySubstitutedClassParameter2() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt");
+                    }
+                    
                     @TestMetadata("HalfSubstitutedTypeParameters.kt")
                     public void testHalfSubstitutedTypeParameters() throws Exception {
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt");
@@ -1606,6 +1646,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SameProjectionKind.kt");
                     }
                     
+                    @TestMetadata("SubclassFromGenericAndNot.kt")
+                    public void testSubclassFromGenericAndNot() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt");
+                    }
+                    
                     @TestMetadata("SubclassOfCollection.kt")
                     public void testSubclassOfCollection() throws Exception {
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt");
@@ -1616,6 +1661,16 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.kt");
                     }
                     
+                    @TestMetadata("SubstitutedClassParameter.kt")
+                    public void testSubstitutedClassParameter() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt");
+                    }
+                    
+                    @TestMetadata("SubstitutedClassParameters.kt")
+                    public void testSubstitutedClassParameters() throws Exception {
+                        doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt");
+                    }
+                    
                     @TestMetadata("TwoSuperclassesConflictingProjectionKinds.kt")
                     public void testTwoSuperclassesConflictingProjectionKinds() throws Exception {
                         doTestNotCheckingPrimaryConstructors("compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt");