KT-3302 Method that implements two differing interfaces are reported as "Incompatible types in superclasses"

#KT-3302 fixed
2013-01-31 18:57:40 +04:00
parent 0f401d4c9d
commit 74771cb2db
36 changed files with 695 additions and 1 deletions
@@ -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);
@@ -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);
+    }
+}
@@ -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)
+    }
+}
@@ -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
+    }
+}
@@ -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);
+    }
+}
@@ -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)
+    }
+}
@@ -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
+    }
+}
@@ -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);
+    }
+}
@@ -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?
+    }
+}
@@ -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?
+    }
+}
@@ -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);
+    }
+}
@@ -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)
+    }
+}
@@ -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
+    }
+}
@@ -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);
+    }
+}
@@ -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)
+    }
+}
@@ -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
+    }
+}
@@ -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);
+    }
+}
@@ -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)
+    }
+}
@@ -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
+    }
+}
@@ -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();
+    }
+}
@@ -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
+    }
+}
@@ -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
+    }
+}
@@ -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();
+    }
+}
@@ -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
+    }
+}
@@ -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
+    }
+}
@@ -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();
+    }
+}
@@ -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
+    }
+}
@@ -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
+    }
+}
@@ -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();
+    }
+}
@@ -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
+    }
+}
@@ -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
+    }
+}
@@ -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();
+    }
+}
@@ -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
+    }
+}
@@ -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
+    }
+}
@@ -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");
@@ -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");