Report warnings on overrides with wrong types nullability

^KT-48899 Fixed

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java

@@ -17848,6 +17848,18 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti
                     runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt");
                 }
 
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesDefinitelyNonNullable() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt");
+                }
+
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesWarning.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesWarning() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.kt");
+                }
+
                 @Test
                 @TestMetadata("returnCollection.kt")
                 public void testReturnCollection() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java

@@ -17848,6 +17848,18 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac
                     runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt");
                 }
 
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesDefinitelyNonNullable() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt");
+                }
+
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesWarning.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesWarning() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.kt");
+                }
+
                 @Test
                 @TestMetadata("returnCollection.kt")
                 public void testReturnCollection() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendForeignAnnotationsCompiledJavaTestGenerated.java

@@ -778,6 +778,12 @@ public class FirOldFrontendForeignAnnotationsCompiledJavaTestGenerated extends A
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendForeignAnnotationsCompiledJavaWithPsiClassReadingTestGenerated.java

@@ -778,6 +778,12 @@ public class FirOldFrontendForeignAnnotationsCompiledJavaWithPsiClassReadingTest
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendForeignAnnotationsSourceJavaTestGenerated.java

@@ -778,6 +778,12 @@ public class FirOldFrontendForeignAnnotationsSourceJavaTestGenerated extends Abs
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt

@@ -189,17 +189,6 @@ class JavaNullabilityChecker(val upperBoundChecker: UpperBoundChecker) : Additio
         return metWrongNullabilityInsideArguments
     }
 
-    private fun isNullableTypeAgainstNotNullTypeParameter(
-        subType: KotlinType,
-        superType: KotlinType
-    ): Boolean {
-        if (superType !is NotNullTypeVariable) return false
-        return !AbstractNullabilityChecker.isSubtypeOfAny(
-            createClassicTypeCheckerState(isErrorTypeEqualsToAnything = true),
-            subType
-        )
-    }
-
     override fun checkReceiver(
         receiverParameter: ReceiverParameterDescriptor,
         receiverArgument: ReceiverValue,
@@ -279,6 +268,10 @@ class JavaNullabilityChecker(val upperBoundChecker: UpperBoundChecker) : Additio
     }
 
     companion object {
+        val typePreparatorUnwrappingEnhancement: KotlinTypePreparator = object : KotlinTypePreparator() {
+            override fun prepareType(type: KotlinTypeMarker): UnwrappedType =
+                super.prepareType(type).let { it.getEnhancementDeeply() ?: it }.unwrap()
+        }
         val typeCheckerForEnhancedTypes = NewKotlinTypeCheckerImpl(
             kotlinTypeRefiner = KotlinTypeRefiner.Default,
             kotlinTypePreparator = object : KotlinTypePreparator() {
@@ -287,6 +280,17 @@ class JavaNullabilityChecker(val upperBoundChecker: UpperBoundChecker) : Additio
             }
         )
         val typeCheckerForBaseTypes = NewKotlinTypeCheckerImpl(KotlinTypeRefiner.Default)
+
+        fun isNullableTypeAgainstNotNullTypeParameter(
+            subType: KotlinType,
+            superType: KotlinType
+        ): Boolean {
+            if (superType !is NotNullTypeVariable || subType is NotNullTypeVariable) return false
+            return !AbstractNullabilityChecker.isSubtypeOfAny(
+                createClassicTypeCheckerState(isErrorTypeEqualsToAnything = true),
+                subType
+            )
+        }
     }
 }
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaOverrideWithWrongNullabilityOverrideChecker.kt

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.resolve.jvm.checkers
+
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.resolve.OverridingUtil
+import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker
+import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
+import org.jetbrains.kotlin.types.*
+
+object JavaOverrideWithWrongNullabilityOverrideChecker : DeclarationChecker {
+    private val overridingUtilWithEnhancementUnwrapped =
+        OverridingUtil
+            .createWithTypePreparatorAndCustomSubtype(JavaNullabilityChecker.typePreparatorUnwrappingEnhancement) { subtype, supertype ->
+            !JavaNullabilityChecker.isNullableTypeAgainstNotNullTypeParameter(subtype, supertype)
+        }
+
+    override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
+        if (descriptor !is CallableMemberDescriptor) return
+        if (descriptor.overriddenDescriptors.isEmpty()) return
+
+        val containingClass = descriptor.containingDeclaration as? ClassDescriptor ?: return
+
+        for (overriddenDescriptor in descriptor.overriddenDescriptors) {
+            if (overriddenDescriptor !is JavaMethodDescriptor) continue
+            // Skip, if even with enhancement unwrapped, it's still a valid override
+            if (overridingUtilWithEnhancementUnwrapped
+                    .isOverridableBy(
+                        overriddenDescriptor, descriptor, containingClass, true
+                    ).result == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) continue
+
+            // Skip if it wasn't an override already before enhancement unwrappement, since errors already have been reported
+            if (OverridingUtil.DEFAULT
+                    .isOverridableBy(
+                        overriddenDescriptor, descriptor, containingClass, true
+                    ).result != OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) continue
+
+
+            val unwrappedOverridden = overriddenDescriptor.substitute(TypeSubstitutor.create(object : TypeSubstitution() {
+                override fun get(key: KotlinType): TypeProjection? = null
+                override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance) =
+                    topLevelType.getEnhancementDeeply() ?: topLevelType
+            })) ?: overriddenDescriptor
+
+            context.trace.report(ErrorsJvm.WRONG_NULLABILITY_FOR_JAVA_OVERRIDE.on(declaration, descriptor, unwrappedOverridden))
+
+            break
+        }
+
+    }
+}

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java

@@ -109,6 +109,10 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
         MAP.put(RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS,
                 "Unsafe use of a nullable receiver of type {0}", RENDER_TYPE);
 
+        MAP.put(WRONG_NULLABILITY_FOR_JAVA_OVERRIDE,
+                "Override ''{0}'' has incorrect nullability in its signature comparing with overridden ''{1}''", COMPACT, COMPACT);
+
+
         MAP.put(ANNOTATION_TARGETS_NON_EXISTENT_ACCESSOR,
                 "An accessor will not be generated for ''{0}'', so the annotation will not be written to the class file", STRING);
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java

@@ -7,10 +7,7 @@ package org.jetbrains.kotlin.resolve.jvm.diagnostics;
 
 import com.intellij.psi.PsiElement;
 import org.jetbrains.kotlin.config.LanguageFeature;
-import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
-import org.jetbrains.kotlin.descriptors.Named;
+import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.*;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
@@ -163,6 +160,8 @@ public interface ErrorsJvm {
     DiagnosticFactory1<KtElement, KotlinType> RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS
             = DiagnosticFactory1.create(WARNING);
 
+    DiagnosticFactory2<KtModifierListOwner, CallableMemberDescriptor, CallableMemberDescriptor> WRONG_NULLABILITY_FOR_JAVA_OVERRIDE =
+            DiagnosticFactory2.create(WARNING, OVERRIDE_MODIFIER);
     DiagnosticFactory1<KtAnnotationEntry, String> ANNOTATION_TARGETS_NON_EXISTENT_ACCESSOR = DiagnosticFactory1.create(WARNING);
 
     DiagnosticFactory1<PsiElement, String> SUSPENSION_POINT_INSIDE_MONITOR = DiagnosticFactory1.create(ERROR);

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt

@@ -41,7 +41,8 @@ object JvmPlatformConfigurator : PlatformConfiguratorBase(
         JvmMultifileClassStateChecker,
         DefaultCheckerInTailrec,
         FunctionDelegateMemberNameClashChecker,
-        ClassInheritsJavaSealedClassChecker
+        ClassInheritsJavaSealedClassChecker,
+        JavaOverrideWithWrongNullabilityOverrideChecker,
     ),
 
     additionalCallCheckers = listOf(

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.fir.kt

@@ -0,0 +1,79 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Foo.java
+public interface Foo {}
+// FILE: BaseClass.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class BaseClass {
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+
+// FILE: main.kt
+
+private val FOO = object : Foo {}
+
+class Correct : BaseClass() {
+    override fun everythingNotNullable(x: Foo): Foo {
+        return FOO
+    }
+
+    override fun everythingNullable(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun everythingUnknown(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun mixed(x: Foo): Foo? {
+        return null
+    }
+
+    override fun explicitlyNullnessUnspecified(x: Foo): Foo {
+        return FOO
+    }
+}
+
+class WrongReturnTypes : BaseClass() {
+    override fun everythingNotNullable(x: Foo): Foo? {
+        return null
+    }
+
+    override fun explicitlyNullnessUnspecified(x: Foo): Foo? {
+        return null
+    }
+}
+
+class WrongParameter : BaseClass() {
+    override fun everythingNotNullable(x: Foo?): Foo {
+        return FOO
+    }
+
+    override fun everythingNullable(x: Foo): Foo? {
+        return null
+    }
+
+    override fun everythingUnknown(x: Foo): Foo? {
+        return null
+    }
+
+    override fun mixed(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun explicitlyNullnessUnspecified(x: Foo?): Foo {
+        return FOO
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt

@@ -0,0 +1,79 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Foo.java
+public interface Foo {}
+// FILE: BaseClass.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class BaseClass {
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+
+// FILE: main.kt
+
+private val FOO = object : Foo {}
+
+class Correct : BaseClass() {
+    override fun everythingNotNullable(x: Foo): Foo {
+        return FOO
+    }
+
+    override fun everythingNullable(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun everythingUnknown(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun mixed(x: Foo): Foo? {
+        return null
+    }
+
+    override fun explicitlyNullnessUnspecified(x: Foo): Foo {
+        return FOO
+    }
+}
+
+class WrongReturnTypes : BaseClass() {
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun everythingNotNullable(x: Foo): Foo? {
+        return null
+    }
+
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun explicitlyNullnessUnspecified(x: Foo): Foo? {
+        return null
+    }
+}
+
+class WrongParameter : BaseClass() {
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun everythingNotNullable(x: Foo?): Foo {
+        return FOO
+    }
+
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun everythingNullable(x: Foo): Foo? {
+        return null
+    }
+
+    override fun everythingUnknown(x: Foo): Foo? {
+        return null
+    }
+
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun mixed(x: Foo?): Foo? {
+        return null
+    }
+
+    override fun explicitlyNullnessUnspecified(x: Foo?): Foo {
+        return FOO
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.txt

@@ -0,0 +1,57 @@
+package
+
+private val FOO: FOO.<no name provided>
+
+@org.jspecify.nullness.NullMarked public open class BaseClass {
+    public constructor BaseClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Foo!): Foo!
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Foo!): @org.jspecify.nullness.Nullable Foo!
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): @org.jspecify.nullness.NullnessUnspecified Foo!
+    public open fun explicitlyNullnessUnspecified(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): Foo!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.nullness.Nullable public open fun mixed(/*0*/ x: Foo!): @org.jspecify.nullness.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Correct : BaseClass {
+    public constructor Correct()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun everythingNotNullable(/*0*/ x: Foo): Foo
+    public open override /*1*/ fun everythingNullable(/*0*/ x: Foo?): Foo?
+    public open override /*1*/ fun everythingUnknown(/*0*/ x: Foo?): Foo?
+    public open override /*1*/ fun explicitlyNullnessUnspecified(/*0*/ x: Foo): Foo
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun mixed(/*0*/ x: Foo): Foo?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class WrongParameter : BaseClass {
+    public constructor WrongParameter()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun everythingNotNullable(/*0*/ x: Foo?): Foo
+    public open override /*1*/ fun everythingNullable(/*0*/ x: Foo): Foo?
+    public open override /*1*/ fun everythingUnknown(/*0*/ x: Foo): Foo?
+    public open override /*1*/ fun explicitlyNullnessUnspecified(/*0*/ x: Foo?): Foo
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun mixed(/*0*/ x: Foo?): Foo?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class WrongReturnTypes : BaseClass {
+    public constructor WrongReturnTypes()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun everythingNotNullable(/*0*/ x: Foo): Foo?
+    @org.jspecify.nullness.Nullable public open override /*1*/ /*fake_override*/ fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Foo!): @org.jspecify.nullness.Nullable Foo!
+    @org.jspecify.nullness.NullnessUnspecified public open override /*1*/ /*fake_override*/ fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): @org.jspecify.nullness.NullnessUnspecified Foo!
+    public open override /*1*/ fun explicitlyNullnessUnspecified(/*0*/ x: Foo): Foo?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.nullness.Nullable public open override /*1*/ /*fake_override*/ fun mixed(/*0*/ x: Foo!): @org.jspecify.nullness.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.fir.kt

@@ -0,0 +1,39 @@
+// !SKIP_JAVAC
+// !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !LANGUAGE: +DefinitelyNonNullableTypes
+// FILE: SLRUMap.java
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+
+public interface SLRUMap<V> {
+    void takeV(@NotNull V value);
+    <E> void takeE(@NotNull E value);
+
+    void takeVList(@NotNull List<@NotNull V> value);
+    <E> void takeEList(@NotNull List<@NotNull E> value);
+
+    public <K> K id(K value) { return null; }
+}
+
+// FILE: main.kt
+
+interface Q1<X> : SLRUMap<X> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun takeV(x: X)
+    override fun <E1> takeE(e: E1)
+
+    <!NOTHING_TO_OVERRIDE!>override<!> fun takeVList(l: List<X>)
+    override fun <E2> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}
+
+interface Q2<X> : SLRUMap<X> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun takeV(x: X & Any)
+    <!NOTHING_TO_OVERRIDE!>override<!> fun <E1> takeE(e: E1 & Any)
+
+    override fun takeVList(l: List<X & Any>)
+    override fun <E2> takeEList(l2: List<E2 & Any>)
+
+    override fun <K2> id(k2: K2): K2
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt

@@ -0,0 +1,39 @@
+// !SKIP_JAVAC
+// !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !LANGUAGE: +DefinitelyNonNullableTypes
+// FILE: SLRUMap.java
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+
+public interface SLRUMap<V> {
+    void takeV(@NotNull V value);
+    <E> void takeE(@NotNull E value);
+
+    void takeVList(@NotNull List<@NotNull V> value);
+    <E> void takeEList(@NotNull List<@NotNull E> value);
+
+    public <K> K id(K value) { return null; }
+}
+
+// FILE: main.kt
+
+interface Q1<X> : SLRUMap<X> {
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun takeV(x: X)
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun <E1> takeE(e: E1)
+
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun takeVList(l: List<X>)
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun <E2> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}
+
+interface Q2<X> : SLRUMap<X> {
+    override fun takeV(x: X & Any)
+    override fun <E1> takeE(e: E1 & Any)
+
+    override fun takeVList(l: List<X & Any>)
+    override fun <E2> takeEList(l2: List<E2 & Any>)
+
+    override fun <K2> id(k2: K2): K2
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.txt

@@ -0,0 +1,34 @@
+package
+
+public interface Q1</*0*/ X> : SLRUMap<X> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ fun </*0*/ K2> id(/*0*/ k2: K2): K2
+    public abstract override /*1*/ fun </*0*/ E1> takeE(/*0*/ e: E1): kotlin.Unit
+    public abstract override /*1*/ fun </*0*/ E2> takeEList(/*0*/ l2: kotlin.collections.List<E2>): kotlin.Unit
+    public abstract override /*1*/ fun takeV(/*0*/ x: X): kotlin.Unit
+    public abstract override /*1*/ fun takeVList(/*0*/ l: kotlin.collections.List<X>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Q2</*0*/ X> : SLRUMap<X> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ fun </*0*/ K2> id(/*0*/ k2: K2): K2
+    public abstract override /*1*/ fun </*0*/ E1> takeE(/*0*/ e: E1 & Any): kotlin.Unit
+    public abstract override /*1*/ fun </*0*/ E2> takeEList(/*0*/ l2: kotlin.collections.List<E2 & Any>): kotlin.Unit
+    public abstract override /*1*/ fun takeV(/*0*/ x: X & Any): kotlin.Unit
+    public abstract override /*1*/ fun takeVList(/*0*/ l: kotlin.collections.List<X & Any>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface SLRUMap</*0*/ V : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun </*0*/ K : kotlin.Any!> id(/*0*/ value: K!): K!
+    public abstract fun </*0*/ E : kotlin.Any!> takeE(/*0*/ @org.jetbrains.annotations.NotNull value: E): kotlin.Unit
+    public abstract fun </*0*/ E : kotlin.Any!> takeEList(/*0*/ @org.jetbrains.annotations.NotNull value: kotlin.collections.(Mutable)List<@org.jetbrains.annotations.NotNull E>): kotlin.Unit
+    public abstract fun takeV(/*0*/ @org.jetbrains.annotations.NotNull value: V): kotlin.Unit
+    public abstract fun takeVList(/*0*/ @org.jetbrains.annotations.NotNull value: kotlin.collections.(Mutable)List<@org.jetbrains.annotations.NotNull V>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.fir.kt

@@ -0,0 +1,38 @@
+// !SKIP_JAVAC
+// !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// FILE: SLRUMap.java
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+
+public interface SLRUMap<V> {
+    void takeV(@NotNull V value);
+    <E> void takeE(@NotNull E value);
+
+    void takeVList(@NotNull List<@NotNull V> value);
+    <E> void takeEList(@NotNull List<@NotNull E> value);
+
+    public <K> K id(K value) { return null; }
+}
+
+// FILE: main.kt
+
+interface Q1<X> : SLRUMap<X> {
+    <!NOTHING_TO_OVERRIDE!>override<!> fun takeV(x: X)
+    override fun <E1> takeE(e: E1)
+
+    <!NOTHING_TO_OVERRIDE!>override<!> fun takeVList(l: List<X>)
+    override fun <E2> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}
+
+interface Q2<X : Any> : SLRUMap<X> {
+    override fun takeV(x: X)
+    override fun <E1 : Any> takeE(e: E1)
+
+    override fun takeVList(l: List<X>)
+    override fun <E2 : Any> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.kt

@@ -0,0 +1,38 @@
+// !SKIP_JAVAC
+// !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// FILE: SLRUMap.java
+
+import org.jetbrains.annotations.NotNull;
+import java.util.List;
+
+public interface SLRUMap<V> {
+    void takeV(@NotNull V value);
+    <E> void takeE(@NotNull E value);
+
+    void takeVList(@NotNull List<@NotNull V> value);
+    <E> void takeEList(@NotNull List<@NotNull E> value);
+
+    public <K> K id(K value) { return null; }
+}
+
+// FILE: main.kt
+
+interface Q1<X> : SLRUMap<X> {
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun takeV(x: X)
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun <E1> takeE(e: E1)
+
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun takeVList(l: List<X>)
+    <!WRONG_NULLABILITY_FOR_JAVA_OVERRIDE!>override<!> fun <E2> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}
+
+interface Q2<X : Any> : SLRUMap<X> {
+    override fun takeV(x: X)
+    override fun <E1 : Any> takeE(e: E1)
+
+    override fun takeVList(l: List<X>)
+    override fun <E2 : Any> takeEList(l2: List<E2>)
+
+    override fun <K2> id(k2: K2): K2
+}

compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.txt

@@ -0,0 +1,34 @@
+package
+
+public interface Q1</*0*/ X> : SLRUMap<X> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ fun </*0*/ K2> id(/*0*/ k2: K2): K2
+    public abstract override /*1*/ fun </*0*/ E1> takeE(/*0*/ e: E1): kotlin.Unit
+    public abstract override /*1*/ fun </*0*/ E2> takeEList(/*0*/ l2: kotlin.collections.List<E2>): kotlin.Unit
+    public abstract override /*1*/ fun takeV(/*0*/ x: X): kotlin.Unit
+    public abstract override /*1*/ fun takeVList(/*0*/ l: kotlin.collections.List<X>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Q2</*0*/ X : kotlin.Any> : SLRUMap<X> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract override /*1*/ fun </*0*/ K2> id(/*0*/ k2: K2): K2
+    public abstract override /*1*/ fun </*0*/ E1 : kotlin.Any> takeE(/*0*/ e: E1): kotlin.Unit
+    public abstract override /*1*/ fun </*0*/ E2 : kotlin.Any> takeEList(/*0*/ l2: kotlin.collections.List<E2>): kotlin.Unit
+    public abstract override /*1*/ fun takeV(/*0*/ x: X): kotlin.Unit
+    public abstract override /*1*/ fun takeVList(/*0*/ l: kotlin.collections.List<X>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface SLRUMap</*0*/ V : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun </*0*/ K : kotlin.Any!> id(/*0*/ value: K!): K!
+    public abstract fun </*0*/ E : kotlin.Any!> takeE(/*0*/ @org.jetbrains.annotations.NotNull value: E): kotlin.Unit
+    public abstract fun </*0*/ E : kotlin.Any!> takeEList(/*0*/ @org.jetbrains.annotations.NotNull value: kotlin.collections.(Mutable)List<@org.jetbrains.annotations.NotNull E>): kotlin.Unit
+    public abstract fun takeV(/*0*/ @org.jetbrains.annotations.NotNull value: V): kotlin.Unit
+    public abstract fun takeVList(/*0*/ @org.jetbrains.annotations.NotNull value: kotlin.collections.(Mutable)List<@org.jetbrains.annotations.NotNull V>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -17854,6 +17854,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                     runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt");
                 }
 
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesDefinitelyNonNullable() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesDefinitelyNonNullable.kt");
+                }
+
+                @Test
+                @TestMetadata("notNullTypeParameterWithKotlinOverridesWarning.kt")
+                public void testNotNullTypeParameterWithKotlinOverridesWarning() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinOverridesWarning.kt");
+                }
+
                 @Test
                 @TestMetadata("returnCollection.kt")
                 public void testReturnCollection() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ForeignAnnotationsCompiledJavaTestGenerated.java

@@ -778,6 +778,12 @@ public class ForeignAnnotationsCompiledJavaTestGenerated extends AbstractForeign
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ForeignAnnotationsCompiledJavaWithPsiClassReadingTestGenerated.java

@@ -778,6 +778,12 @@ public class ForeignAnnotationsCompiledJavaWithPsiClassReadingTestGenerated exte
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/ForeignAnnotationsSourceJavaTestGenerated.java

@@ -778,6 +778,12 @@ public class ForeignAnnotationsSourceJavaTestGenerated extends AbstractForeignAn
                     runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt");
                 }
 
+                @Test
+                @TestMetadata("OverrideOfAnnotated.kt")
+                public void testOverrideOfAnnotated() throws Exception {
+                    runTest("compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/OverrideOfAnnotated.kt");
+                }
+
                 @Test
                 @TestMetadata("SelfType.kt")
                 public void testSelfType() throws Exception {