Move foreign annotation tests into diagnostics folder

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/checkerFramework.kt

@@ -0,0 +1,41 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SOURCE_RETENTION_ANNOTATIONS
+// FILE: A.java
+import org.checkerframework.checker.nullness.qual.*;
+
+public class A<T> {
+    @Nullable public String field = null;
+
+    @Nullable
+    public String foo(@NonNull String x, @Nullable CharSequence y) {
+        return "";
+    }
+
+    @NonNull
+    public String bar() {
+        return "";
+    }
+
+    @Nullable
+    public T baz(@NonNull T x) { return x; }
+}
+
+// FILE: main.kt
+fun main(a: A<String>, a1: A<String?>) {
+    a.foo("", null)?.length
+    a.foo("", null)<!UNSAFE_CALL!>.<!>length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, "")<!UNSAFE_CALL!>.<!>length
+
+    a.bar().length
+    a.bar()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+
+    a.field?.length
+    a.field<!UNSAFE_CALL!>.<!>length
+
+    a.baz("")<!UNSAFE_CALL!>.<!>length
+    a.baz("")?.length
+    a.baz(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>length
+
+    a1.baz("")!!.length
+    a1.baz(<!NULL_FOR_NONNULL_TYPE!>null<!>)!!.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/checkerFramework.txt

@@ -0,0 +1,14 @@
+package
+
+public fun main(/*0*/ a: A<kotlin.String>, /*1*/ a1: A<kotlin.String?>): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!>()
+    @org.checkerframework.checker.nullness.qual.Nullable public final var field: @org.checkerframework.checker.nullness.qual.Nullable kotlin.String?
+    @org.checkerframework.checker.nullness.qual.NonNull public open fun bar(): @org.checkerframework.checker.nullness.qual.NonNull kotlin.String
+    @org.checkerframework.checker.nullness.qual.Nullable public open fun baz(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull T): @org.checkerframework.checker.nullness.qual.Nullable T?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.checkerframework.checker.nullness.qual.Nullable public open fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull kotlin.String, /*1*/ @org.checkerframework.checker.nullness.qual.Nullable y: @org.checkerframework.checker.nullness.qual.Nullable kotlin.CharSequence?): @org.checkerframework.checker.nullness.qual.Nullable kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/eclipse.kt

@@ -0,0 +1,41 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SOURCE_RETENTION_ANNOTATIONS
+// FILE: A.java
+import org.eclipse.jdt.annotation.*;
+
+public class A<T> {
+    @Nullable public String field = null;
+
+    @Nullable
+    public String foo(@NonNull String x, @Nullable CharSequence y) {
+        return "";
+    }
+
+    @NonNull
+    public String bar() {
+        return "";
+    }
+
+    @Nullable
+    public T baz(@NonNull T x) { return x; }
+}
+
+// FILE: main.kt
+fun main(a: A<String>, a1: A<String?>) {
+    a.foo("", null)?.length
+    a.foo("", null)<!UNSAFE_CALL!>.<!>length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, "")<!UNSAFE_CALL!>.<!>length
+
+    a.bar().length
+    a.bar()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+
+    a.field?.length
+    a.field<!UNSAFE_CALL!>.<!>length
+
+    a.baz("")<!UNSAFE_CALL!>.<!>length
+    a.baz("")?.length
+    a.baz(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>length
+
+    a1.baz("")!!.length
+    a1.baz(<!NULL_FOR_NONNULL_TYPE!>null<!>)!!.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/eclipse.txt

@@ -0,0 +1,14 @@
+package
+
+public fun main(/*0*/ a: A<kotlin.String>, /*1*/ a1: A<kotlin.String?>): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!>()
+    @org.eclipse.jdt.annotation.Nullable public final var field: @org.eclipse.jdt.annotation.Nullable kotlin.String?
+    @org.eclipse.jdt.annotation.NonNull public open fun bar(): @org.eclipse.jdt.annotation.NonNull kotlin.String
+    @org.eclipse.jdt.annotation.Nullable public open fun baz(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull T): @org.eclipse.jdt.annotation.Nullable T?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.eclipse.jdt.annotation.Nullable public open fun foo(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull kotlin.String, /*1*/ @org.eclipse.jdt.annotation.Nullable y: @org.eclipse.jdt.annotation.Nullable kotlin.CharSequence?): @org.eclipse.jdt.annotation.Nullable kotlin.String?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.fir.kt

@@ -0,0 +1,88 @@
+// JSPECIFY_STATE: strict
+
+// FILE: AnnotatedBoundsOfWildcard.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNull<!>)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.fir.txt

@@ -0,0 +1,38 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base, out Base, out Base>): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base, in Base, in Base>): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.kt

@@ -0,0 +1,88 @@
+// JSPECIFY_STATE: strict
+
+// FILE: AnnotatedBoundsOfWildcard.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNull<!>)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.txt

@@ -0,0 +1,39 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base, out Base, out Base>): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base, in Base, in Base>): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.fir.kt

@@ -0,0 +1,50 @@
+// JSPECIFY_STATE: strict
+
+// FILE: Defaults.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    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: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.fir.txt

@@ -0,0 +1,25 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo?
+    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 open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.kt

@@ -0,0 +1,50 @@
+// JSPECIFY_STATE: strict
+
+// FILE: Defaults.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    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: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.txt

@@ -0,0 +1,26 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo?
+    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 open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.fir.kt

@@ -0,0 +1,48 @@
+// JSPECIFY_STATE: strict
+
+// FILE: IgnoreAnnotations.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.fir.txt

@@ -0,0 +1,31 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived): Derived
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived?): @org.jspecify.nullness.Nullable Derived?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.kt

@@ -0,0 +1,48 @@
+// JSPECIFY_STATE: strict
+
+// FILE: IgnoreAnnotations.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.txt

@@ -0,0 +1,32 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived): Derived
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived?): @org.jspecify.nullness.Nullable Derived?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// JSPECIFY_STATE: strict
+
+// FILE: NonPlatformTypeParameter.java
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T> {
+    public constructor NonPlatformTypeParameter</*0*/ T>()
+    public open fun </*0*/ E> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// JSPECIFY_STATE: strict
+
+// FILE: NonPlatformTypeParameter.java
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.txt

@@ -0,0 +1,20 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T> {
+    public constructor NonPlatformTypeParameter</*0*/ T>()
+    public open fun </*0*/ E> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt

@@ -0,0 +1,38 @@
+// JSPECIFY_STATE: strict
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any>()
+    public open fun bar(/*0*/ s: Test, /*1*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.kt

@@ -0,0 +1,38 @@
+// JSPECIFY_STATE: strict
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.txt

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any>()
+    public open fun bar(/*0*/ s: Test, /*1*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.fir.kt

@@ -0,0 +1,58 @@
+// JSPECIFY_STATE: strict
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.fir.txt

@@ -0,0 +1,67 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>> {
+    public constructor SelfType</*0*/ T : SelfType<T!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.kt

@@ -0,0 +1,58 @@
+// JSPECIFY_STATE: strict
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.txt

@@ -0,0 +1,68 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>> {
+    public constructor SelfType</*0*/ T : SelfType<T!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.fir.kt

@@ -0,0 +1,39 @@
+// JSPECIFY_STATE: strict
+
+// FILE: Simple.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open fun bar(): Derived
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.kt

@@ -0,0 +1,39 @@
+// JSPECIFY_STATE: strict
+
+// FILE: Simple.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.txt

@@ -0,0 +1,29 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open fun bar(): Derived
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.fir.kt

@@ -0,0 +1,49 @@
+// JSPECIFY_STATE: strict
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.fir.txt

@@ -0,0 +1,33 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test, Test>): kotlin.Unit
+    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 open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test?, Test!>!): kotlin.Unit
+    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 open class Test {
+    public constructor Test()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.kt

@@ -0,0 +1,49 @@
+// JSPECIFY_STATE: strict
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.txt

@@ -0,0 +1,34 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test, Test>): kotlin.Unit
+    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 open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test?, Test!>!): kotlin.Unit
+    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 open class Test {
+    public constructor Test()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt

@@ -0,0 +1,47 @@
+// JSPECIFY_STATE: strict
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any> {
+    public constructor A</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any> {
+    public constructor B</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.kt

@@ -0,0 +1,47 @@
+// JSPECIFY_STATE: strict
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.txt

@@ -0,0 +1,29 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any> {
+    public constructor A</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any> {
+    public constructor B</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.fir.kt

@@ -0,0 +1,37 @@
+// JSPECIFY_STATE: strict
+
+// FILE: WildcardsWithDefault.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    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 fun noBoundsNotNull(/*0*/ a: A<out kotlin.Any, out @org.jspecify.nullness.Nullable kotlin.Any, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any>): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.kt

@@ -0,0 +1,37 @@
+// JSPECIFY_STATE: strict
+
+// FILE: WildcardsWithDefault.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.txt

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    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 fun noBoundsNotNull(/*0*/ a: A<out kotlin.Any, out @org.jspecify.nullness.Nullable kotlin.Any, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any>): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,88 @@
+// JSPECIFY_MUTE
+
+// FILE: AnnotatedBoundsOfWildcard.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNull)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/AnnotatedBoundsOfWildcard.fir.txt

@@ -0,0 +1,38 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base!, out Base!, out Base!>!): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>!): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base!, in Base!, in Base!>!): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,88 @@
+// JSPECIFY_MUTE
+
+// FILE: AnnotatedBoundsOfWildcard.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNull)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

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

@@ -0,0 +1,39 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base!, out Base!, out Base!>!): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>!): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base!, in Base!, in Base!>!): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,49 @@
+
+// FILE: Defaults.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    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: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Defaults.fir.txt

@@ -0,0 +1,25 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo!
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo!
+    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 open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,49 @@
+
+// FILE: Defaults.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    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: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

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

@@ -0,0 +1,26 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo!
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo!
+    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 open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,47 @@
+
+// FILE: IgnoreAnnotations.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/IgnoreAnnotations.fir.txt

@@ -0,0 +1,31 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived!): Derived!
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived!): @org.jspecify.nullness.Nullable Derived!
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,47 @@
+
+// FILE: IgnoreAnnotations.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

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

@@ -0,0 +1,32 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived!): Derived!
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived!): @org.jspecify.nullness.Nullable Derived!
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,29 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// JSPECIFY_MUTE
+
+// FILE: NonPlatformTypeParameter.java
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T : @org.jspecify.nullness.Nullable kotlin.Any!> {
+    public constructor NonPlatformTypeParameter</*0*/ T : @org.jspecify.nullness.Nullable kotlin.Any!>()
+    public open fun </*0*/ E : @org.jspecify.nullness.Nullable kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

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

@@ -0,0 +1,29 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// JSPECIFY_MUTE
+
+// FILE: NonPlatformTypeParameter.java
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

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

@@ -0,0 +1,20 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T : @org.jspecify.nullness.Nullable kotlin.Any!> {
+    public constructor NonPlatformTypeParameter</*0*/ T : @org.jspecify.nullness.Nullable kotlin.Any!>()
+    public open fun </*0*/ E : @org.jspecify.nullness.Nullable kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

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

@@ -0,0 +1,38 @@
+// JSPECIFY_MUTE
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!>()
+    public open fun bar(/*0*/ s: Test!, /*1*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

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

@@ -0,0 +1,38 @@
+// JSPECIFY_MUTE
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

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

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!>()
+    public open fun bar(/*0*/ s: Test!, /*1*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

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

@@ -0,0 +1,58 @@
+// JSPECIFY_MUTE
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/SelfType.fir.txt

@@ -0,0 +1,67 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>!> {
+    public constructor SelfType</*0*/ T : SelfType<T!>!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,58 @@
+// JSPECIFY_MUTE
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

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

@@ -0,0 +1,68 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>!> {
+    public constructor SelfType</*0*/ T : SelfType<T!>!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,38 @@
+
+// FILE: Simple.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Simple.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived!
+    public open fun bar(): Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,38 @@
+
+// FILE: Simple.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

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

@@ -0,0 +1,29 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    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 open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived!
+    public open fun bar(): Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,49 @@
+// JSPECIFY_MUTE
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeArgumentsFromParameterBounds.fir.txt

@@ -0,0 +1,33 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    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 open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    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 open class Test {
+    public constructor Test()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,49 @@
+// JSPECIFY_MUTE
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

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

@@ -0,0 +1,34 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    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 open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    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 open class Test {
+    public constructor Test()
+    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
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

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

@@ -0,0 +1,47 @@
+// JSPECIFY_MUTE
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!>()
+    public open fun </*0*/ E : kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any!> {
+    public constructor B</*0*/ T : kotlin.Any!>()
+    public open fun </*0*/ E : kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}

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

@@ -0,0 +1,47 @@
+// JSPECIFY_MUTE
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

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

@@ -0,0 +1,29 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!>()
+    public open fun </*0*/ E : kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any!> {
+    public constructor B</*0*/ T : kotlin.Any!>()
+    public open fun </*0*/ E : kotlin.Any!> bar(/*0*/ e: E!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    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
+}
+

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

@@ -0,0 +1,37 @@
+// JSPECIFY_MUTE
+
+// FILE: WildcardsWithDefault.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/WildcardsWithDefault.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    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 fun noBoundsNotNull(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -0,0 +1,37 @@
+// JSPECIFY_MUTE
+
+// FILE: WildcardsWithDefault.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

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

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.nullness.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    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 fun noBoundsNotNull(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToType.kt

@@ -0,0 +1,77 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SKIP_JAVAC
+// SOURCE_RETENTION_ANNOTATIONS
+// JSR305_GLOBAL_REPORT: strict
+
+// FILE: spr/NonNullApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+
+@Target({ElementType.TYPE, ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NonNullApi {
+}
+
+// FILE: spr/NullableApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+import javax.annotation.meta.When;
+
+@Target({ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull(when = When.MAYBE)
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NullableApi {
+}
+
+// FILE: A.java
+import spr.*;
+import java.util.*;
+
+@NonNullApi
+public class A {
+    public String foo(String x) { return ""; }
+    public @NullableApi String bar(@NullableApi String y) { return ""; }
+    public @NullableApi List<String> baz1() { return null; }
+    public List<@NullableApi String> baz2() { return null; }
+    public @NullableApi List<@NonNullApi String> baz3() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: A) {
+    a.foo("").length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+
+    a.bar("")<!UNSAFE_CALL!>.<!>length
+    a.bar(null)?.length
+
+    a.baz1()<!UNSAFE_CALL!>.<!>get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)?.length
+
+    a.baz2().get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)?.length
+
+    a.baz3()<!UNSAFE_CALL!>.<!>get(0).length
+    a.baz3()!!.get(0).length
+    a.baz3()!!.get(0)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToType.txt

@@ -0,0 +1,32 @@
+package
+
+public fun main(/*0*/ a: A): kotlin.Unit
+
+@spr.NonNullApi public open class A {
+    public constructor A()
+    @spr.NullableApi public open fun bar(/*0*/ @spr.NullableApi y: @spr.NullableApi kotlin.String?): @spr.NullableApi kotlin.String?
+    @spr.NullableApi public open fun baz1(): (@spr.NullableApi kotlin.collections.MutableList<kotlin.String?>?..@spr.NullableApi kotlin.collections.List<kotlin.String?>?)
+    public open fun baz2(): kotlin.collections.(Mutable)List<@spr.NullableApi kotlin.String?>
+    @spr.NullableApi public open fun baz3(): (@spr.NullableApi kotlin.collections.MutableList<@spr.NonNullApi kotlin.String>?..@spr.NullableApi kotlin.collections.List<@spr.NonNullApi kotlin.String>?)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package spr {
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation {
+        public constructor NonNullApi()
+        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
+    }
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NullableApi : kotlin.Annotation {
+        public constructor NullableApi()
+        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
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt

@@ -0,0 +1,67 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SKIP_JAVAC
+// SOURCE_RETENTION_ANNOTATIONS
+// JSR305_GLOBAL_REPORT: strict
+
+// FILE: spr/NonNullApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+
+@Target({ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NonNullApi {
+}
+
+// FILE: spr/NullableApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+import javax.annotation.meta.When;
+
+@Target({ElementType.TYPE, ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull(when = When.MAYBE)
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NullableApi {
+}
+
+// FILE: A.java
+import spr.*;
+import java.util.*;
+
+@NonNullApi
+public class A {
+    public String foo(String x) { return ""; }
+    public @NullableApi String bar(@NullableApi String y) { return ""; }
+    public @NullableApi List<String> baz1() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: A) {
+    a.foo("").length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+
+    a.bar("")<!UNSAFE_CALL!>.<!>length
+    a.bar(null)?.length
+
+    a.baz1()<!UNSAFE_CALL!>.<!>get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)?.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.txt

@@ -0,0 +1,30 @@
+package
+
+public fun main(/*0*/ a: A): kotlin.Unit
+
+@spr.NonNullApi public open class A {
+    public constructor A()
+    @spr.NullableApi public open fun bar(/*0*/ @spr.NullableApi y: @spr.NullableApi kotlin.String?): @spr.NullableApi kotlin.String?
+    @spr.NullableApi public open fun baz1(): (@spr.NullableApi kotlin.collections.MutableList<kotlin.String?>?..@spr.NullableApi kotlin.collections.List<kotlin.String?>?)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package spr {
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation {
+        public constructor NonNullApi()
+        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
+    }
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NullableApi : kotlin.Annotation {
+        public constructor NullableApi()
+        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
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/springNullableWithTypeUse.kt

@@ -0,0 +1,79 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: strict
+
+// FILE: spr/Nullable.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.When;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull(when = When.MAYBE)
+@TypeQualifierNickname
+public @interface Nullable {
+}
+
+// FILE: spr/NonNullApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NonNullApi {
+}
+
+// FILE: A.java
+import spr.*;
+
+@NonNullApi
+public class A {
+    public String field = null;
+
+    public String foo(String x, @Nullable CharSequence y) {
+        return "";
+    }
+
+    public String bar() {
+        return "";
+    }
+
+    @Nullable
+    public java.util.List<String> baz() {
+        return null;
+    }
+}
+
+// FILE: main.kt
+fun main(a: A) {
+    a.foo("", null)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+    a.foo("", null).length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, "").length
+
+    a.bar().length
+    a.bar()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+
+    a.field<!UNNECESSARY_SAFE_CALL!>?.<!>length
+    a.field.length
+
+    a.baz()<!UNSAFE_CALL!>.<!>get(0)
+    a.baz()!!.get(0).get(0)
+    a.baz()!!.get(0)<!UNNECESSARY_SAFE_CALL!>?.<!>get(0)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/springNullableWithTypeUse.txt

@@ -0,0 +1,31 @@
+package
+
+public fun main(/*0*/ a: A): kotlin.Unit
+
+@spr.NonNullApi public open class A {
+    public constructor A()
+    public final var field: kotlin.String
+    public open fun bar(): kotlin.String
+    @spr.Nullable public open fun baz(): kotlin.collections.(Mutable)List<kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ x: kotlin.String, /*1*/ @spr.Nullable y: kotlin.CharSequence?): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package spr {
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation {
+        public constructor NonNullApi()
+        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
+    }
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierNickname public final annotation class Nullable : kotlin.Annotation {
+        public constructor Nullable()
+        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
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt

@@ -0,0 +1,108 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+// RENDER_PACKAGE: test
+// SOURCE_RETENTION_ANNOTATIONS
+// WITH_RUNTIME
+// JSR305_GLOBAL_REPORT: strict
+
+// FILE: spr/Nullable.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierNickname;
+import javax.annotation.meta.When;
+
+@Target({ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull(when = When.MAYBE)
+@TypeQualifierNickname
+public @interface Nullable {
+}
+
+// FILE: spr/NonNullApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+
+@Target(ElementType.PACKAGE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NonNullApi {
+}
+
+// FILE: test/package-info.java
+@spr.NonNullApi()
+package test;
+
+// FILE: test/L.java
+package test;
+
+public class L<T extends java.util.Map<String, S>, S> {
+    public T t() { return null; }
+    public S s() { return null; }
+
+    public void setT(@spr.Nullable T t) {}
+    public void setS(S s) {}
+}
+
+// FILE: test/A.java
+package test;
+
+import spr.*;
+import java.util.*;
+
+public class A {
+    public void foo(L<Map<String, Integer>, @Nullable Integer> l) {}
+    public void bar(L<?, Integer> l) {}
+    public L<Map<String, Integer>, @Nullable Integer> baz1() { return null; }
+    public L<?, Integer> baz2() { return null; }
+    public L<? extends Map<String, Integer>, Integer> baz3() { return null; }
+}
+
+// FILE: main.kt
+import test.L
+
+fun main(a: test.A, l: L<Map<String, Int>, Int?>, l1: L<Map<String, Int>, Int>) {
+    a.foo(l)
+    a.foo(<!TYPE_MISMATCH!>l <!UNCHECKED_CAST!>as L<Map<String, Int>, Int><!><!>)
+    a.foo(<!TYPE_MISMATCH!>l <!UNCHECKED_CAST!>as L<Map<String, Int?>, Int?><!><!>)
+
+    a.bar(l1)
+    a.bar(<!TYPE_MISMATCH!>l1 <!UNCHECKED_CAST!>as L<Map<String, Int>, Int?><!><!>)
+
+    a.baz1().t().containsKey("")
+    a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
+    a.baz1().t().containsValue(1)
+    a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
+    a.baz1().s().hashCode()
+
+    a.baz1().setT(l.t())
+    a.baz1().setT(<!TYPE_MISMATCH!>l.t() <!UNCHECKED_CAST!>as L<Map<String, Int>, Int><!><!>)
+    a.baz1().setT(null)
+
+    a.baz2().t().containsKey("")
+    a.baz2().t().containsKey(null)
+    a.baz2().t().containsValue(1)
+    a.baz2().t().containsValue(null)
+    a.baz2().s().hashCode()
+
+    a.baz3().t().containsKey("")
+    a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
+    a.baz3().t().containsValue(1)
+    a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
+    a.baz3().s().hashCode()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.txt

@@ -0,0 +1,71 @@
+package test
+
+public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ l: test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>): kotlin.Unit
+    public open fun baz1(): test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>
+    public open fun baz2(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>
+    public open fun baz3(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, kotlin.Int>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class L</*0*/ T : kotlin.collections.(Mutable)Map<kotlin.String!, S!>!, /*1*/ S : kotlin.Any!> {
+    public constructor L</*0*/ T : kotlin.collections.(Mutable)Map<kotlin.String!, S!>!, /*1*/ S : 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 open fun s(): S
+    public open fun setS(/*0*/ s: S): kotlin.Unit
+    public open fun setT(/*0*/ @spr.Nullable t: @spr.Nullable T?): kotlin.Unit
+    public open fun t(): T
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package
+
+public fun main(/*0*/ a: test.A, /*1*/ l: test.L<kotlin.collections.Map<kotlin.String, kotlin.Int>, kotlin.Int?>, /*2*/ l1: test.L<kotlin.collections.Map<kotlin.String, kotlin.Int>, kotlin.Int>): kotlin.Unit
+
+package spr {
+
+    @kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation {
+        public constructor NonNullApi()
+        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
+    }
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierNickname public final annotation class Nullable : kotlin.Annotation {
+        public constructor Nullable()
+        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
+    }
+}
+
+package test {
+
+    public open class A {
+        public constructor A()
+        public open fun bar(/*0*/ l: test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>): kotlin.Unit
+        public open fun baz1(): test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>
+        public open fun baz2(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>
+        public open fun baz3(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(/*0*/ l: test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class L</*0*/ T : kotlin.collections.(Mutable)Map<kotlin.String!, S!>!, /*1*/ S : kotlin.Any!> {
+        public constructor L</*0*/ T : kotlin.collections.(Mutable)Map<kotlin.String!, S!>!, /*1*/ S : 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 open fun s(): S
+        public open fun setS(/*0*/ s: S): kotlin.Unit
+        public open fun setT(/*0*/ @spr.Nullable t: @spr.Nullable T?): kotlin.Unit
+        public open fun t(): T
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeUseVsMethodConflict.kt

@@ -0,0 +1,77 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SKIP_JAVAC
+// SOURCE_RETENTION_ANNOTATIONS
+// JSR305_GLOBAL_REPORT: strict
+
+// FILE: spr/NonNullApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+
+@Target({ElementType.TYPE, ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull
+@TypeQualifierDefault({ElementType.TYPE_USE, ElementType.METHOD})
+public @interface NonNullApi {
+}
+
+// FILE: spr/NullableApi.java
+package spr;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierDefault;
+import javax.annotation.meta.When;
+
+@Target({ElementType.TYPE_USE})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Nonnull(when = When.MAYBE)
+@TypeQualifierDefault({ElementType.TYPE_USE})
+public @interface NullableApi {
+}
+
+// FILE: A.java
+import spr.*;
+import java.util.*;
+
+@NonNullApi
+public class A {
+    public String foo(String x) { return ""; }
+    public @NullableApi String bar(@NullableApi String y) { return ""; }
+    public @NullableApi List<String> baz1() { return null; }
+    public List<@NullableApi String> baz2() { return null; }
+    public @NullableApi List<@NonNullApi String> baz3() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: A) {
+    a.foo("").length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+
+    a.bar("")<!UNSAFE_CALL!>.<!>length
+    a.bar(null)?.length
+
+    a.baz1()<!UNSAFE_CALL!>.<!>get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz1()!!.get(0)?.length
+
+    a.baz2().get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)<!UNSAFE_CALL!>.<!>length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)?.length
+
+    a.baz3()<!UNSAFE_CALL!>.<!>get(0).length
+    a.baz3()!!.get(0).length
+    a.baz3()!!.get(0)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeUseVsMethodConflict.txt

@@ -0,0 +1,32 @@
+package
+
+public fun main(/*0*/ a: A): kotlin.Unit
+
+@spr.NonNullApi public open class A {
+    public constructor A()
+    @spr.NullableApi public open fun bar(/*0*/ @spr.NullableApi y: @spr.NullableApi kotlin.String?): @spr.NullableApi kotlin.String?
+    @spr.NullableApi public open fun baz1(): (@spr.NullableApi kotlin.collections.MutableList<kotlin.String?>?..@spr.NullableApi kotlin.collections.List<kotlin.String?>?)
+    public open fun baz2(): kotlin.collections.(Mutable)List<@spr.NullableApi kotlin.String?>
+    @spr.NullableApi public open fun baz3(): (@spr.NullableApi kotlin.collections.MutableList<@spr.NonNullApi kotlin.String>?..@spr.NullableApi kotlin.collections.List<@spr.NonNullApi kotlin.String>?)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ x: kotlin.String): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package spr {
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE, ElementType.METHOD}) public final annotation class NonNullApi : kotlin.Annotation {
+        public constructor NonNullApi()
+        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
+    }
+
+    @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NullableApi : kotlin.Annotation {
+        public constructor NullableApi()
+        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
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/classTypeParameterBound.fir.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+// FILE: ClassTypeParameterBound.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBound <T extends @NotNull String> {
+    ClassTypeParameterBound(T x) { }
+    ClassTypeParameterBound() { }
+}
+
+// FILE: main.kt
+fun main(x: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>, y: ClassTypeParameterBound<String>, a: String?, b: String) {
+    val x2 = ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>()
+    val y2 = ClassTypeParameterBound<String>()
+
+    val x3 = ClassTypeParameterBound(<!TYPE_MISMATCH!>a<!>)
+    val y3 = ClassTypeParameterBound(b)
+
+    val x4: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>> = <!TYPE_MISMATCH!>ClassTypeParameterBound()<!>
+    val y4: ClassTypeParameterBound<String> = ClassTypeParameterBound()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/classTypeParameterBound.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+// FILE: ClassTypeParameterBound.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBound <T extends @NotNull String> {
+    ClassTypeParameterBound(T x) { }
+    ClassTypeParameterBound() { }
+}
+
+// FILE: main.kt
+fun main(x: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>, y: ClassTypeParameterBound<String>, a: String?, b: String) {
+    val x2 = ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>()
+    val y2 = ClassTypeParameterBound<String>()
+
+    val x3 = ClassTypeParameterBound(<!TYPE_MISMATCH!>a<!>)
+    val y3 = ClassTypeParameterBound(b)
+
+    val x4: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>> = <!TYPE_MISMATCH!>ClassTypeParameterBound()<!>
+    val y4: ClassTypeParameterBound<String> = ClassTypeParameterBound()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/classTypeParameterBoundWithWarnings.fir.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+// FILE: ClassTypeParameterBoundWithWarnings.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBoundWithWarnings <T extends @NotNull String> {
+    ClassTypeParameterBoundWithWarnings() { }
+    ClassTypeParameterBoundWithWarnings(T x) { }
+}
+
+// FILE: main.kt
+fun main(x: ClassTypeParameterBoundWithWarnings<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>String?<!>>, y: ClassTypeParameterBoundWithWarnings<String>, a: String?, b: String) {
+    val x2 = ClassTypeParameterBoundWithWarnings<String?>()
+    val y2 = ClassTypeParameterBoundWithWarnings<String>()
+
+    val x3 = ClassTypeParameterBoundWithWarnings(a)
+    val y3 = ClassTypeParameterBoundWithWarnings(b)
+
+    val x4: ClassTypeParameterBoundWithWarnings<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>String?<!>> = ClassTypeParameterBoundWithWarnings()
+    val y4: ClassTypeParameterBoundWithWarnings<String> = ClassTypeParameterBoundWithWarnings()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/classTypeParameterBoundWithWarnings.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+// FILE: ClassTypeParameterBoundWithWarnings.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBoundWithWarnings <T extends @NotNull String> {
+    ClassTypeParameterBoundWithWarnings() { }
+    ClassTypeParameterBoundWithWarnings(T x) { }
+}
+
+// FILE: main.kt
+fun main(x: ClassTypeParameterBoundWithWarnings<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>String?<!>>, y: ClassTypeParameterBoundWithWarnings<String>, a: String?, b: String) {
+    val x2 = ClassTypeParameterBoundWithWarnings<String?>()
+    val y2 = ClassTypeParameterBoundWithWarnings<String>()
+
+    val x3 = ClassTypeParameterBoundWithWarnings(a)
+    val y3 = ClassTypeParameterBoundWithWarnings(b)
+
+    val x4: ClassTypeParameterBoundWithWarnings<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>String?<!>> = ClassTypeParameterBoundWithWarnings()
+    val y4: ClassTypeParameterBoundWithWarnings<String> = ClassTypeParameterBoundWithWarnings()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/returnType.fir.kt

@@ -0,0 +1,65 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+// FILE: ReturnType.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.*;
+
+public class ReturnType<T> {
+    public interface A<T1, T2> {}
+
+    public A<@Nullable String, @Nullable T> foo1() { return null; }
+    public A<@Nullable String, @NotNull T> foo2() { return null; }
+    public A<@NotNull String, @NotNull T> foo3 = null;
+    public @NotNull T [] foo4 = null;
+    public ReturnType<@Nullable String> foo41 = null;
+    public T foo411 = null;
+    public @Nullable String [] foo5() { return null; }
+}
+
+// FILE: main.kt
+fun <K> takeNotNullStringAndKNullable(x: ReturnType.A<String, K?>) {}
+fun <K> takeNullableStringAndKNullable(x: ReturnType.A<String?, K?>) {}
+fun <K: Any> takeNotNullStringAndNotNullK(x: ReturnType.A<String, K>) {}
+fun <K: Any> takeNullableStringAndNotNullK(x: ReturnType.A<String?, K>) {}
+fun takeNotNullString(x: String) {}
+
+fun takeArrayOfNotNullString(x: Array<String>) {}
+fun takeArrayOfNullableString(x: Array<String?>) {}
+fun <K: Any> takeArrayOfNotNullK(x: Array<K>) {}
+fun <K> takeArrayOfNullableK(x: Array<K?>) {}
+
+fun <R> main(a: ReturnType<R>) {
+    val x1 = a.foo1()
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(<!TYPE_MISMATCH!>a.foo41.foo411<!>)
+
+    val x2 = a.foo2()
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndNotNullK(x2)
+
+    val x3 = a.foo3
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNotNullStringAndNotNullK(x3)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH!>x3<!>)
+
+    val x4 = a.foo4
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(x4)
+    takeArrayOfNullableK(<!TYPE_MISMATCH!>x4<!>)
+
+    val x5 = a.foo5()
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(x5)
+    takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(x5)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/typeEnhancement/onCompiled/returnType.kt

@@ -0,0 +1,65 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+// FILE: ReturnType.java
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.*;
+
+public class ReturnType<T> {
+    public interface A<T1, T2> {}
+
+    public A<@Nullable String, @Nullable T> foo1() { return null; }
+    public A<@Nullable String, @NotNull T> foo2() { return null; }
+    public A<@NotNull String, @NotNull T> foo3 = null;
+    public @NotNull T [] foo4 = null;
+    public ReturnType<@Nullable String> foo41 = null;
+    public T foo411 = null;
+    public @Nullable String [] foo5() { return null; }
+}
+
+// FILE: main.kt
+fun <K> takeNotNullStringAndKNullable(x: ReturnType.A<String, K?>) {}
+fun <K> takeNullableStringAndKNullable(x: ReturnType.A<String?, K?>) {}
+fun <K: Any> takeNotNullStringAndNotNullK(x: ReturnType.A<String, K>) {}
+fun <K: Any> takeNullableStringAndNotNullK(x: ReturnType.A<String?, K>) {}
+fun takeNotNullString(x: String) {}
+
+fun takeArrayOfNotNullString(x: Array<String>) {}
+fun takeArrayOfNullableString(x: Array<String?>) {}
+fun <K: Any> takeArrayOfNotNullK(x: Array<K>) {}
+fun <K> takeArrayOfNullableK(x: Array<K?>) {}
+
+fun <R> main(a: ReturnType<R>) {
+    val x1 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.Nullable R?>..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.Nullable R?>?)")!>a.foo1()<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String, TypeVariable(K)>; ReturnType.A<String?, R?>!")!>x1<!>)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(<!TYPE_MISMATCH!>a.foo41.foo411<!>)
+
+    val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull R!!>..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo2()<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String, TypeVariable(K)>; ReturnType.A<String?, R!!>!")!>x2<!>)
+    takeNullableStringAndNotNullK(x2)
+
+    val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.NotNull kotlin.String, @org.jetbrains.annotations.NotNull R!!>..ReturnType.A<@org.jetbrains.annotations.NotNull kotlin.String, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo3<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNotNullStringAndNotNullK(x3)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String?, TypeVariable(K)>; ReturnType.A<String, R!!>!")!>x3<!>)
+
+    val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<@org.jetbrains.annotations.NotNull R!!>..kotlin.Array<out @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo4<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(x4)
+    takeArrayOfNullableK(<!TYPE_MISMATCH!>x4<!>)
+
+    val x5 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>..kotlin.Array<out @org.jetbrains.annotations.Nullable kotlin.String?>?)")!>a.foo5()<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(x5)
+    takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(x5)
+}