Generate foreign annotation test data for FIR

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // SOURCE_RETENTION_ANNOTATIONS
 // FILE: A.java

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // SOURCE_RETENTION_ANNOTATIONS
 // FILE: A.java

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

@@ -0,0 +1,81 @@
+// JSPECIFY_STATE: strict
+// MUTE_FOR_PSI_CLASS_FILES_READING
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+
+// 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 {
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    b.superNullable(aAnyNotNullNotNullNull)
+    b.superNullable(aAnyNotNullNullNotNull)
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    b.extendsNotNull(aNotNullNotNullNull)
+    b.extendsNotNull(aNotNullNullNotNull)
+    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/strictMode/Captured.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: strict
 // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
 // FILE: J1.java

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

@@ -0,0 +1,46 @@
+// JSPECIFY_STATE: strict
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+
+// 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 {
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

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

@@ -0,0 +1,44 @@
+// JSPECIFY_STATE: strict
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+
+// 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 {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

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

@@ -0,0 +1,27 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +TypeEnhancementImprovementsInStrictMode
+// JSPECIFY_STATE: strict
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

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

@@ -0,0 +1,31 @@
+// 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
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit {
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

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

@@ -0,0 +1,53 @@
+// 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)
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    bk.foo(bk)
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    ck.foo(null)
+
+    ckn.foo(null)
+}

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

@@ -0,0 +1,37 @@
+// JSPECIFY_STATE: strict
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+
+// 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 {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

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

@@ -0,0 +1,46 @@
+// JSPECIFY_STATE: strict
+// MUTE_FOR_PSI_CLASS_FILES_READING
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+
+// 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)
+    a.bar(aNotNullNotNullNull)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.bar(aNotNullNotNullNotNull)
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

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

@@ -0,0 +1,40 @@
+// 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
+fun <T : Test> main(a1: A<Any?>, a2: A<Test>, b1: B<Any?>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

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

@@ -0,0 +1,35 @@
+// JSPECIFY_STATE: strict
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: strict
 // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
 // MUTE_FOR_PSI_CLASS_FILES_READING

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

@@ -0,0 +1,135 @@
+// JSPECIFY_STATE: strict
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: Foo.java
+import org.jspecify.nullness.*;
+
+public interface Foo<T extends @Nullable Object> {}
+
+// FILE: Util.java
+public class Util {
+    public static Foo<String> getFooOfString() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilNullMarked.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class UtilNullMarked {
+    public static Foo<String> getFooOfString() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilNullMarkedGeneric.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class UtilNullMarkedGeneric {
+    public static <K> Foo<K> getFooOfK() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilNullMarkedGenericNullableBound.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class UtilNullMarkedGenericNullableBound {
+    public static <K extends @Nullable Object> Foo<K> getFooOfK() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilGenericNullableBound.java
+import org.jspecify.nullness.*;
+
+public class UtilGenericNullableBound {
+    public static <K extends @Nullable Object> Foo<K> getFooOfK() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilNullMarkedGenericNullnessUnspecifiedBound.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class UtilNullMarkedGenericNullnessUnspecifiedBound {
+    public static <K extends @NullnessUnspecified Object> Foo<K> getFooOfK() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: UtilGenericNullnessUnspecifiedBound.java
+import org.jspecify.nullness.*;
+
+public class UtilGenericNullnessUnspecifiedBound {
+    public static <K extends @NullnessUnspecified Object> Foo<K> getFooOfK() {
+        throw new RuntimeException();
+    }
+}
+
+// FILE: main.kt
+
+// no errors on this call means String in Foo is flexible
+fun isNotNullAndNullableStringInFoo(x: Foo<String>, y: Foo<String?>) {}
+
+fun test1() {
+    // String in Foo is flexible
+    isNotNullAndNullableStringInFoo(
+        Util.getFooOfString(),
+        Util.getFooOfString()
+    )
+}
+
+fun test2() {
+    // String in Foo is not null
+    isNotNullAndNullableStringInFoo(
+        UtilNullMarked.getFooOfString(),
+        UtilNullMarked.getFooOfString()
+    )
+}
+
+fun test3() {
+    // String in Foo is not null
+    isNotNullAndNullableStringInFoo(
+        UtilNullMarkedGeneric.getFooOfK(),
+        UtilNullMarkedGeneric.getFooOfK()
+    )
+}
+
+fun test4() {
+    // String in Foo is flexible
+    isNotNullAndNullableStringInFoo(
+        UtilNullMarkedGenericNullableBound.getFooOfK(),
+        UtilNullMarkedGenericNullableBound.getFooOfK()
+    )
+}
+
+fun test5() {
+    // String in Foo is flexible
+    isNotNullAndNullableStringInFoo(
+        UtilGenericNullableBound.getFooOfK(),
+        UtilGenericNullableBound.getFooOfK()
+    )
+}
+
+fun test6() {
+    // String in Foo is flexible
+    isNotNullAndNullableStringInFoo(
+        UtilNullMarkedGenericNullnessUnspecifiedBound.getFooOfK(),
+        UtilNullMarkedGenericNullnessUnspecifiedBound.getFooOfK()
+    )
+}
+
+fun test7() {
+    // String in Foo is flexible
+    isNotNullAndNullableStringInFoo(
+        UtilGenericNullnessUnspecifiedBound.getFooOfK(),
+        UtilGenericNullnessUnspecifiedBound.getFooOfK()
+    )
+}

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

@@ -0,0 +1,18 @@
+// JSPECIFY_STATE: strict
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: Foo.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Foo<T extends @Nullable Object> {
+    static <T extends Comparable> Foo<T> create() {
+        return new Foo<>();
+    }
+}
+
+// FILE: main.kt
+fun test(): Foo<String> {
+    return <!DEBUG_INFO_EXPRESSION_TYPE("Foo<kotlin.String..kotlin.String?!>")!>Foo.create()<!>
+}

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

@@ -0,0 +1,80 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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 {
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    b.superNullable(aAnyNotNullNotNullNull)
+    b.superNullable(aAnyNotNullNullNotNull)
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    b.extendsNotNull(aNotNullNotNullNull)
+    b.extendsNotNull(aNotNullNullNotNull)
+    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/Captured.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: warn
 // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
 // FILE: J1.java

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

@@ -0,0 +1,45 @@
+// JSPECIFY_STATE: warn
+
+// 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 {
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

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

@@ -0,0 +1,43 @@
+// JSPECIFY_STATE: warn
+
+// 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 {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

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

@@ -0,0 +1,27 @@
+// JSPECIFY_STATE: warn
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

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

@@ -0,0 +1,30 @@
+// JSPECIFY_STATE: warn
+// 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
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit {
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

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

@@ -0,0 +1,54 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>) // the corresponding warning/error is present on the Java side
+
+    bk.foo(bk)
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    ck.foo(null)
+
+    ckn.foo(null) // the corresponding warning/error is present on the Java side
+}

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

@@ -0,0 +1,36 @@
+// JSPECIFY_STATE: warn
+
+// 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 {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

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

@@ -0,0 +1,45 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    a.bar(aNotNullNotNullNull)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.bar(aNotNullNotNullNotNull)
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

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

@@ -0,0 +1,39 @@
+// JSPECIFY_STATE: warn
+// 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
+fun <T : Test> main(a1: A<Any?>, a2: A<Test>, b1: B<Any?>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

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

@@ -0,0 +1,35 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// 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)
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

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

@@ -0,0 +1,15 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Foo.java
+import org.jspecify.nullness.Nullable;
+
+public class Foo {
+    public static <T> void gauge(@Nullable T stateObject) {}
+}
+
+// FILE: main.kt
+fun <T> test(metric: T) {
+    if (metric is String) {
+        Foo.gauge(metric)
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToType.fir.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)?.length
+
+    a.bar("").length
+    a.bar(null)?.length
+
+    a.baz1().get(0).length
+    a.baz1()!!.get(0).length
+    a.baz1()!!.get(0)?.length
+
+    a.baz2().get(0).length
+    a.baz2()!!.get(0).length
+    a.baz2()!!.get(0)?.length
+
+    a.baz3().get(0).length
+    a.baz3()!!.get(0).length
+    a.baz3()!!.get(0)?.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.fir.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)?.length
+
+    a.bar("").length
+    a.bar(null)?.length
+
+    a.baz1().get(0).length
+    a.baz1()!!.get(0).length
+    a.baz1()!!.get(0)?.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/springNullableWithTypeUse.fir.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)?.length
+    a.foo("", null).length
+    a.foo(null, "").length
+
+    a.bar().length
+    a.bar()!!.length
+
+    a.field?.length
+    a.field.length
+
+    a.baz()<!UNSAFE_CALL!>.<!>get(0)
+    a.baz()!!.get(0).get(0)
+    a.baz()!!.get(0)?.get(0)
+}

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

@@ -0,0 +1,107 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// 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(l as L<Map<String, Int>, Int>)
+    a.foo(l as L<Map<String, Int?>, Int?>)
+
+    a.bar(l1)
+    a.bar(l1 as L<Map<String, Int>, Int?>)
+
+    a.baz1().t().containsKey("")
+    a.baz1().t().containsKey(null)
+    a.baz1().t().containsValue(1)
+    a.baz1().t().containsValue(null)
+    a.baz1().s().hashCode()
+
+    a.baz1().setT(l.t())
+    a.baz1().setT(<!ARGUMENT_TYPE_MISMATCH!>l.t() 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().containsKey(null)
+    a.baz3().t().containsValue(1)
+    a.baz3().t().containsValue(null)
+    a.baz3().s().hashCode()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeUseVsMethodConflict.fir.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)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+
+    a.bar("").length
+    a.bar(null)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+
+    a.baz1().get(0).length
+    a.baz1()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0).length
+    a.baz1()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)?.length
+
+    a.baz2().get(0).length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0).length
+    a.baz2()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)?.length
+
+    a.baz3().get(0).length
+    a.baz3()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0).length
+    a.baz3()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.get(0)?.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/annotatedTypeArguments.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JAVAC_EXPECTED_FILE
 // FILE: AnnotatedTypeArguments.java
 import org.checkerframework.checker.nullness.qual.*;

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBound.fir.kt

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

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBoundWithWarnings.fir.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated, -TypeEnhancementImprovementsInStrictMode
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: ClassTypeParameterBoundWithWarnings.java
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBoundWithWarnings <T extends @NotNull String> {
+    ClassTypeParameterBoundWithWarnings() { }
+    ClassTypeParameterBoundWithWarnings(T x) { }
+}
+
+// FILE: main.kt
+fun main(x: ClassTypeParameterBoundWithWarnings<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<String?> = ClassTypeParameterBoundWithWarnings()
+    val y4: ClassTypeParameterBoundWithWarnings<String> = ClassTypeParameterBoundWithWarnings()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/enhancedRecursiveStarProjection.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // FILE: I1.java
 import org.checkerframework.checker.nullness.qual.NonNull;

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/methodWithTypeParameter.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JAVAC_EXPECTED_FILE
 // FILE: Outer.java
 import org.checkerframework.checker.nullness.qual.*;

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/notNullVarargsOverrides.fir.kt

@@ -0,0 +1,21 @@
+// SOURCE_RETENTION_ANNOTATIONS
+// FILE: BaseClass.java
+import org.checkerframework.checker.nullness.qual.*;
+
+public class BaseClass {
+    public void loadCache(@NonNull Object... args) {}
+}
+
+// FILE: main.kt
+class A : BaseClass() {
+    // org.checkerframework.checker.nullness.qual.NonNull has @Target TYPE_USE, so it affects only elements type
+    override fun loadCache(vararg args: Any?) {
+        super.loadCache(*args)
+    }
+}
+
+class B : BaseClass() {
+    override fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/nullableVarargsOverrides.fir.kt

@@ -0,0 +1,21 @@
+// SOURCE_RETENTION_ANNOTATIONS
+// FILE: BaseClass.java
+import org.checkerframework.checker.nullness.qual.*;
+
+public class BaseClass {
+    public void loadCache(@Nullable Object... args) {}
+}
+
+// FILE: main.kt
+class A : BaseClass() {
+    override fun loadCache(vararg args: Any?) {
+        super.loadCache(*args)
+    }
+}
+
+class B : BaseClass() {
+    // org.checkerframework.checker.nullness.qual.Nullable has @Target TYPE_USE, so it affects only elements type
+    override fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnType.fir.kt

@@ -0,0 +1,65 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: ReturnType.java
+
+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<kotlin.String?, R..R?!>..ReturnType.A<kotlin.String?, R..R?!>?!")!>a.foo1()<!>
+    takeNotNullStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(a.foo41.foo411)
+
+    val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("ReturnType.A<kotlin.String, R..R?!>..ReturnType.A<kotlin.String, R..R?!>?!")!>a.foo2()<!>
+    takeNotNullStringAndKNullable(x2)
+    takeNullableStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+
+    val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("ReturnType.A<kotlin.String, R..R?!>..ReturnType.A<kotlin.String, R..R?!>?!")!>a.foo3<!>
+    takeNotNullStringAndKNullable(x3)
+    takeNullableStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+
+    val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Array<R..R?!>..kotlin.Array<out R..R?!>")!>a.foo4<!>
+    takeArrayOfNotNullString(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableK(x4)
+
+    val x5 = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Array<kotlin.String..kotlin.String?!>?..kotlin.Array<out kotlin.String..kotlin.String?!>??")!>a.foo5()<!>
+    takeArrayOfNotNullString(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnTypeDifferentConstructor.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JAVAC_EXPECTED_FILE
 // FILE: Outer.java
 import org.checkerframework.checker.nullness.qual.*;

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnTypeOverrideInKotlin.fir.kt

@@ -0,0 +1,31 @@
+// SOURCE_RETENTION_ANNOTATIONS
+// FILE: Base.java
+public interface Base<T> {}
+// FILE: A.java
+import org.checkerframework.checker.nullness.qual.*;
+
+public class A {
+    @Nullable Base<@NonNull String> foo() { return null; }
+}
+
+// FILE: a.kt
+interface Derived<E> : Base<E> {}
+
+fun bar1(): Derived<String> = null!!
+fun bar2(): Derived<String?> = null!!
+
+class B : A() {
+    override fun foo(): Base<String> { return bar1(); }
+}
+
+class C1 : A() {
+    override fun foo(): Derived<String> { return bar1(); }
+}
+
+class C2 : A() {
+    override fun foo(): Derived<String>? { return bar1(); }
+}
+
+class C3 : A() {
+    override fun foo(): Derived<String?> { return bar2(); }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/returnTypeWithWarnings.fir.kt

@@ -0,0 +1,67 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated, -TypeEnhancementImprovementsInStrictMode
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: ReturnTypeWithWarnings.java
+// We've already had errors in source mode, so it's relevant only for binaries for now
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.*;
+
+public class ReturnTypeWithWarnings<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 ReturnTypeWithWarnings<@Nullable String> foo41 = null;
+    public T foo411 = null;
+    public @Nullable String [] foo5() { return null; }
+}
+
+// FILE: main.kt
+fun <K> takeNotNullStringAndKNullable(x: ReturnTypeWithWarnings.A<String, K?>) {}
+fun <K> takeNullableStringAndKNullable(x: ReturnTypeWithWarnings.A<String?, K?>) {}
+fun <K: Any> takeNotNullStringAndNotNullK(x: ReturnTypeWithWarnings.A<String, K>) {}
+fun <K: Any> takeNullableStringAndNotNullK(x: ReturnTypeWithWarnings.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: ReturnTypeWithWarnings<R>) {
+    val x1 = <!DEBUG_INFO_EXPRESSION_TYPE("ReturnTypeWithWarnings.A<kotlin.String?, R..R?!>..ReturnTypeWithWarnings.A<kotlin.String?, R..R?!>?!")!>a.foo1()<!>
+    takeNotNullStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(a.foo41.foo411)
+
+    val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("ReturnTypeWithWarnings.A<kotlin.String, R..R?!>..ReturnTypeWithWarnings.A<kotlin.String, R..R?!>?!")!>a.foo2()<!>
+    takeNotNullStringAndKNullable(x2)
+    takeNullableStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+
+    val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("ReturnTypeWithWarnings.A<kotlin.String, R..R?!>..ReturnTypeWithWarnings.A<kotlin.String, R..R?!>?!")!>a.foo3<!>
+    takeNotNullStringAndKNullable(x3)
+    takeNullableStringAndKNullable(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+    takeNotNullStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x3<!>)
+
+    val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Array<R..R?!>..kotlin.Array<out R..R?!>")!>a.foo4<!>
+    takeArrayOfNotNullString(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableK(x4)
+
+    val x5 = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Array<kotlin.String..kotlin.String?!>?..kotlin.Array<out kotlin.String..kotlin.String?!>??")!>a.foo5()<!>
+    takeArrayOfNotNullString(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNotNullK(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(<!ARGUMENT_TYPE_MISMATCH!>x5<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/simple.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 import org.checkerframework.checker.nullness.qual.*;
 import java.util.*;

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/useTypeParameterAnnotationToEnhanceItsUsages.fir.kt

@@ -0,0 +1,14 @@
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+import org.jetbrains.annotations.*;
+
+// FILE: MapLike.java
+public interface MapLike<@org.jetbrains.annotations.NotNull K> {
+    void put(K x);
+}
+
+// FILE: main.kt
+fun test2(map : MapLike<Int>, x2: Int?) {
+    map.put(x2)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/valueParameter.fir.kt

@@ -0,0 +1,62 @@
+// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: ValueParameter.java
+
+import org.jetbrains.annotations.*;
+
+public class ValueParameter<T> {
+    public interface A<T1, T2> {}
+
+    public void foo1(A<@Nullable String, @Nullable T> x) { }
+    public void foo2(A<@Nullable String, @NotNull T> x) { }
+    public void foo3(A<@NotNull String, @NotNull T> x) { }
+    public void foo4(@NotNull T [] x) { }
+    public void foo41(@Nullable String x) { }
+    public void foo411(T x) { }
+    public void foo5(@Nullable String [] x) { }
+}
+
+// FILE: main.kt
+fun <K> getNotNullStringAndKNullable() = null as ValueParameter.A<String, K?>
+fun <K> getNullableStringAndKNullable() = null as ValueParameter.A<String?, K?>
+fun <K: Any> getNotNullStringAndNotNullK() = null as ValueParameter.A<String, K>
+fun <K: Any> getNullableStringAndNotNullK() = null as ValueParameter.A<String?, K>
+fun getNotNullString() = null as String
+
+fun getArrayOfNotNullString() = null as Array<String>
+fun getArrayOfNullableString() = null as Array<String?>
+fun <K: Any> getArrayOfNotNullK() = null as Array<K>
+fun <K> getArrayOfNullableK() = null as Array<K?>
+
+fun <R> main(a: ValueParameter<R>) {
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndKNullable()<!>)
+    a.foo1(getNullableStringAndKNullable())
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo2(getNotNullStringAndKNullable())
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo3(getNotNullStringAndKNullable())
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo4(<!ARGUMENT_TYPE_MISMATCH!>getArrayOfNotNullString()<!>)
+    a.foo4(<!ARGUMENT_TYPE_MISMATCH!>getArrayOfNullableString()<!>)
+    a.foo4(getArrayOfNotNullK())
+    a.foo4(getArrayOfNullableK())
+
+    a.foo5(getArrayOfNotNullString())
+    a.foo5(getArrayOfNullableString())
+    a.foo5(getArrayOfNotNullK())
+    a.foo5(getArrayOfNullableK())
+
+    a.foo41(getNotNullString())
+    a.foo411(<!ARGUMENT_TYPE_MISMATCH!>getNotNullString()<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/valueParameterWithWarnings.fir.kt

@@ -0,0 +1,64 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated, -TypeEnhancementImprovementsInStrictMode
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: ValueParameterWithWarnings.java
+// We've already had errors in source mode, so it's relevant only for binaries for now
+// INCLUDE_JAVA_AS_BINARY
+
+import org.jetbrains.annotations.*;
+
+public class ValueParameterWithWarnings<T> {
+    public interface A<T1, T2> {}
+
+    public void foo1(A<@Nullable String, @Nullable T> x) { }
+    public void foo2(A<@Nullable String, @NotNull T> x) { }
+    public void foo3(A<@NotNull String, @NotNull T> x) { }
+    public void foo4(@NotNull T [] x) { }
+    public void foo41(@Nullable String x) { }
+    public void foo411(T x) { }
+    public void foo5(@Nullable String [] x) { }
+}
+
+// FILE: main.kt
+fun <K> getNotNullStringAndKNullable() = null as ValueParameterWithWarnings.A<String, K?>
+fun <K> getNullableStringAndKNullable() = null as ValueParameterWithWarnings.A<String?, K?>
+fun <K: Any> getNotNullStringAndNotNullK() = null as ValueParameterWithWarnings.A<String, K>
+fun <K: Any> getNullableStringAndNotNullK() = null as ValueParameterWithWarnings.A<String?, K>
+fun getNotNullString() = null as String
+
+fun getArrayOfNotNullString() = null as Array<String>
+fun getArrayOfNullableString() = null as Array<String?>
+fun <K: Any> getArrayOfNotNullK() = null as Array<K>
+fun <K> getArrayOfNullableK() = null as Array<K?>
+
+fun <R> main(a: ValueParameterWithWarnings<R>) {
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndKNullable()<!>)
+    a.foo1(getNullableStringAndKNullable())
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo1(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo2(getNotNullStringAndKNullable())
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo2(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo3(getNotNullStringAndKNullable())
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo3(<!ARGUMENT_TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo4(<!ARGUMENT_TYPE_MISMATCH!>getArrayOfNotNullString()<!>)
+    a.foo4(<!ARGUMENT_TYPE_MISMATCH!>getArrayOfNullableString()<!>)
+    a.foo4(getArrayOfNotNullK())
+    a.foo4(getArrayOfNullableK())
+
+    a.foo5(getArrayOfNotNullString())
+    a.foo5(getArrayOfNullableString())
+    a.foo5(getArrayOfNotNullK())
+    a.foo5(getArrayOfNullableK())
+
+    a.foo41(getNotNullString())
+    a.foo411(<!ARGUMENT_TYPE_MISMATCH!>getNotNullString()<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/warningsBasedOnEnhancedBasedType.fir.kt

@@ -0,0 +1,23 @@
+// !LANGUAGE: -TypeEnhancementImprovementsInStrictMode
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SKIP_TXT
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// We've already had errors in source mode, so it's relevant only for binaries for now
+
+// FILE: Base.java
+// INCLUDE_JAVA_AS_BINARY
+public class Base<K> {}
+
+// FILE: Test.java
+// INCLUDE_JAVA_AS_BINARY
+import org.jetbrains.annotations.Nullable;
+
+class Test extends Base<@Nullable String> {}
+
+// FILE: main.kt
+fun takeBaseOfNotNullStrings(x: Base<String>) {}
+
+fun main() {
+    val x = takeBaseOfNotNullStrings(Test())
+}

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // FILE: A.java
 import org.checkerframework.checker.nullness.qual.*;
 public class A {

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/basic.fir.kt

@@ -0,0 +1,25 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/composeWithClassDefaultAnnotation.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // ALLOW_KOTLIN_PACKAGE
 // JSPECIFY_STATE: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/composeWithPackageDefaultAnnotation.fir.kt

@@ -0,0 +1,31 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/package-info.java
+@NullMarked
+package test;
+
+import org.jspecify.nullness.NullMarked;
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/dependentModulesNoNullMarked.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // ALLOW_KOTLIN_PACKAGE
 // JSPECIFY_STATE: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/dependentModulesNullMarked.fir.kt

@@ -0,0 +1,30 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// MODULE: module1
+// FILE: module1/module-info.java
+module module1 {
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module2 {
+    requires java9_annotations;
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test.java
+package test2;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+fun main(y: test2.Test) {
+    y.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/dontPropagateModuleAnnotationToAnotherModuleWithSamePackage.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // ALLOW_KOTLIN_PACKAGE
 // JSPECIFY_STATE: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/dotNamedModule.fir.kt

@@ -0,0 +1,25 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// FILE: my.sand.box/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+open module my.sand.box {
+    requires java9_annotations;
+    exports my.test;
+}
+
+// FILE: my.sand.box/my/test/Test.java
+package my.test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import my.test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/inheritanceAcrossModules.fir.kt

@@ -0,0 +1,45 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// MODULE: module1
+// FILE: module1/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module1 {
+    requires java9_annotations;
+    exports test1;
+}
+
+// FILE: module1/test1/Test1.java
+package test1;
+
+public class Test1 {
+    public void foo(Integer x) {}
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+module module2 {
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test2.java
+package test2;
+
+import test1.Test1;
+
+public class Test2 extends Test1 {
+    public void foo2(Integer x) {}
+}
+
+// FILE: main.kt
+import test1.Test1
+import test2.Test2
+
+fun main(x: Test1, y: Test2) {
+    x.foo(null)
+    y.foo(null)
+    y.foo2(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/nestedClasses.fir.kt

@@ -0,0 +1,43 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public static class Test2 {
+        public Integer foo(Integer x) { return 1; }
+        public static class Test4 {
+            public Integer foo(Integer x) { return 1; }
+        }
+        public class Test5 {
+            public Integer foo(Integer x) { return 1; }
+        }
+    }
+    public class Test3 {
+        public Integer foo(Integer x) { return 1; }
+        public class Test5 {
+            public Integer foo(Integer x) { return 1; }
+        }
+    }
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>x.Test3().foo(null)<!>
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>x.Test3().Test5().foo(null)<!>
+
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>Test.Test2().foo(null)<!>
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>Test.Test2().Test5().foo(null)<!>
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/overrideAtDeclarationLevel.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // ALLOW_KOTLIN_PACKAGE
 // JSPECIFY_STATE: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/strict/severalModulesDifferentPackages.fir.kt

@@ -0,0 +1,39 @@
+// ALLOW_KOTLIN_PACKAGE
+// JSPECIFY_STATE: strict
+
+// MODULE: module1
+// FILE: module1/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module1 {
+    requires java9_annotations;
+    exports test1;
+}
+
+// FILE: module1/test1/Test.java
+package test1;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+module module2 {
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test.java
+package test2;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+fun main(x: test1.Test, y: test2.Test) {
+    x.foo(null)
+    y.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/basic.fir.kt

@@ -0,0 +1,25 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/composeWithClassDefaultAnnotation.fir.kt

@@ -0,0 +1,28 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// FILE: sandbox/test/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/Test.java
+package test;
+
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    x.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/composeWithPackageDefaultAnnotation.fir.kt

@@ -0,0 +1,31 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/package-info.java
+@NullMarked
+package test;
+
+import org.jspecify.nullness.NullMarked;
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/dependentModulesNoNullMarked.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: warn
 // ALLOW_KOTLIN_PACKAGE
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/dependentModulesNullMarked.fir.kt

@@ -0,0 +1,30 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// MODULE: module1
+// FILE: module1/module-info.java
+module module1 {
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module2 {
+    requires java9_annotations;
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test.java
+package test2;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+fun main(y: test2.Test) {
+    y.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/dontPropagateModuleAnnotationToAnotherModuleWithSamePackage.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: warn
 // ALLOW_KOTLIN_PACKAGE
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/dotNamedModule.fir.kt

@@ -0,0 +1,25 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// FILE: my.sand.box/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+open module my.sand.box {
+    requires java9_annotations;
+    exports my.test;
+}
+
+// FILE: my.sand.box/my/test/Test.java
+package my.test;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+import my.test.Test
+
+fun main(x: Test) {
+    x.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/inheritanceAcrossModules.fir.kt

@@ -0,0 +1,45 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// MODULE: module1
+// FILE: module1/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module1 {
+    requires java9_annotations;
+    exports test1;
+}
+
+// FILE: module1/test1/Test1.java
+package test1;
+
+public class Test1 {
+    public void foo(Integer x) {}
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+module module2 {
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test2.java
+package test2;
+
+import test1.Test1;
+
+public class Test2 extends Test1 {
+    public void foo2(Integer x) {}
+}
+
+// FILE: main.kt
+import test1.Test1
+import test2.Test2
+
+fun main(x: Test1, y: Test2) {
+    x.foo(null)
+    y.foo(null)
+    y.foo2(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/nestedClasses.fir.kt

@@ -0,0 +1,43 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// FILE: sandbox/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module sandbox {
+    requires java9_annotations;
+    exports test;
+}
+
+// FILE: sandbox/test/Test.java
+package test;
+
+public class Test {
+    public static class Test2 {
+        public Integer foo(Integer x) { return 1; }
+        public static class Test4 {
+            public Integer foo(Integer x) { return 1; }
+        }
+        public class Test5 {
+            public Integer foo(Integer x) { return 1; }
+        }
+    }
+    public class Test3 {
+        public Integer foo(Integer x) { return 1; }
+        public class Test5 {
+            public Integer foo(Integer x) { return 1; }
+        }
+    }
+}
+
+// FILE: main.kt
+import test.Test
+
+fun main(x: Test) {
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>x.Test3().foo(null)<!>
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>x.Test3().Test5().foo(null)<!>
+
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>Test.Test2().foo(null)<!>
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int..kotlin.Int?!")!>Test.Test2().Test5().foo(null)<!>
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/overrideAtDeclarationLevel.kt

@@ -1,3 +1,5 @@
+// FIR_IDENTICAL
+// FIR_IDENTICAL
 // JSPECIFY_STATE: warn
 // ALLOW_KOTLIN_PACKAGE
 

compiler/testData/diagnostics/foreignAnnotationsTests/java9Tests/jspecify/moduleAnnotations/warn/severalModulesDifferentPackages.fir.kt

@@ -0,0 +1,39 @@
+// JSPECIFY_STATE: warn
+// ALLOW_KOTLIN_PACKAGE
+
+// MODULE: module1
+// FILE: module1/module-info.java
+import org.jspecify.nullness.NullMarked;
+
+@NullMarked
+module module1 {
+    requires java9_annotations;
+    exports test1;
+}
+
+// FILE: module1/test1/Test.java
+package test1;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// MODULE: module2(module1)
+// FILE: module2/module-info.java
+module module2 {
+    requires module1;
+    exports test2;
+}
+
+// FILE: module2/test2/Test.java
+package test2;
+
+public class Test {
+    public void foo(Integer x) {}
+}
+
+// FILE: main.kt
+fun main(x: test1.Test, y: test2.Test) {
+    x.foo(null)
+    y.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/androidRecently.fir.kt

@@ -0,0 +1,52 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+
+// FILE: A.java
+import androidx.annotation.*;
+
+public class A<T> {
+    @RecentlyNullable public String field = null;
+
+    @RecentlyNullable
+    public String foo(@RecentlyNonNull String x, @RecentlyNullable CharSequence y) {
+        return "";
+    }
+
+    @RecentlyNonNull
+    public String bar() {
+        return "";
+    }
+
+    @RecentlyNullable
+    public T baz(@RecentlyNonNull T x) { return x; }
+
+    @RecentlyNonNull
+    public T baz2(@RecentlyNullable 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
+
+    a.baz2("").length
+    a.baz2("")<!UNNECESSARY_SAFE_CALL!>?.<!>length
+    a.baz2("")<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+
+    a.baz2(null).length
+    a.baz2(null)<!UNNECESSARY_SAFE_CALL!>?.<!>length
+    a.baz2(null)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/androidSdk.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/android_support.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/androidx.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/aosp.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // SOURCE_RETENTION_ANNOTATIONS
 

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

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

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/findBugsSimple.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: A.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/irrelevantQualifierNicknames.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 // FILE: UnknownQualifier.java

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/dontIgnoreAnnotationsWithoutTarget.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // JSR305_GLOBAL_REPORT: strict

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/ignore/parametersAreNonnullByDefault.fir.kt

@@ -0,0 +1,33 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: ignore
+
+// FILE: A.java
+import javax.annotation.*;
+
+@ParametersAreNonnullByDefault
+public class A {
+    @Nullable public String field = null;
+
+    public String foo(String q, @Nonnull String x, @CheckForNull CharSequence y) {
+        return "";
+    }
+
+    @Nonnull
+    public String bar() {
+        return "";
+    }
+}
+
+// FILE: main.kt
+fun main(a: A) {
+    // foo is platform
+    a.foo("", "", null)?.length
+    a.foo("", "", null).length
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>, "").length
+
+    a.bar().length
+    a.bar()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>.length
+
+    a.field?.length
+    a.field<!UNSAFE_CALL!>.<!>length
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nonNullNever.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // JSR305_GLOBAL_REPORT: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityNicknames.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // JSR305_GLOBAL_REPORT: strict
 

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/elvis.fir.kt

@@ -0,0 +1,85 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: MyNotNull.java
+import javax.annotation.Nonnull;
+import javax.annotation.meta.TypeQualifierNickname;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.PARAMETER})
+@Nonnull
+@TypeQualifierNickname
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyNotNull {}
+
+
+// FILE: AnnotatedWithJsr.java
+public class AnnotatedWithJsr {
+    @MyNotNull
+    public String getString() {
+        return null;
+    }
+
+    public void consumeString(@MyNotNull String s) { }
+}
+
+
+
+// FILE: AnnotatedWithJB.java
+import org.jetbrains.annotations.NotNull;
+
+public class AnnotatedWithJB {
+    public @NotNull String getString() {
+        return "hello";
+    }
+
+    public void consumeString(@NotNull String s) { }
+}
+
+
+// FILE: PlainJava.java
+public class PlainJava {
+    public String getString() {
+        return null;
+    }
+
+    public void consumeString(String s) { }
+}
+
+
+// FILE: main.kt
+val jsr: AnnotatedWithJsr = AnnotatedWithJsr()
+val jsrNullable: AnnotatedWithJsr? = null
+
+val jb: AnnotatedWithJB = AnnotatedWithJB()
+val jbNullable: AnnotatedWithJB? = null
+
+val platform: PlainJava = PlainJava()
+val platformNullable: PlainJava? = null
+
+object Elvis {
+    fun fromJava() {
+        val a = jsr.string <!USELESS_ELVIS!>?: ""<!>
+        val b = jsrNullable?.string ?: ""
+
+        val c = jb.string <!USELESS_ELVIS!>?: ""<!>
+        val d = jbNullable?.string ?: ""
+
+        val e = platform.string ?: ""
+        val f = platformNullable?.string ?: ""
+    }
+
+    fun toJava(nullableString: String?) {
+        val b = jsr.consumeString(nullableString ?: "")
+        val d = jsrNullable?.consumeString(nullableString ?: "")
+
+        val f = jb.consumeString(nullableString ?: "")
+        val h = jbNullable?.consumeString(nullableString ?: "")
+
+        val j = platform.consumeString(nullableString ?: "")
+        val l = platformNullable?.consumeString(nullableString ?: "")
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/arithmetic.fir.kt

@@ -0,0 +1,49 @@
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static Integer staticNN;
+    @MyNullable
+    public static Integer staticN;
+    public static Integer staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    var platformNN = J.staticNN
+    var platformN = J.staticN
+    var platformJ = J.staticJ
+
+    +platformNN
+    <!UNSAFE_CALL!>+<!>platformN
+    +platformJ
+
+    ++platformNN
+    <!UNSAFE_CALL!>++<!>platformN
+    ++platformJ
+
+    platformNN++
+    platformN++
+    platformJ++
+
+    1 + platformNN
+    1 + platformN
+    1 + platformJ
+
+    platformNN + 1
+    platformN + 1
+    platformJ + 1
+
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformNN
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformN
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformJ
+
+    platformNN <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
+    platformN <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
+    platformJ <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
+
+    platformNN += 1
+    platformN += 1
+    platformJ += 1
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/array.fir.kt

@@ -0,0 +1,25 @@
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static Integer[] staticNN;
+    @MyNullable
+    public static Integer[] staticN;
+    public static Integer[] staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    val platformNN = J.staticNN
+    val platformN = J.staticN
+    val platformJ = J.staticJ
+
+    platformNN[0]
+    <!UNSAFE_CALL!>platformN[0]<!>
+    platformJ[0]
+
+    platformNN[0] = 1
+    <!UNSAFE_CALL!>platformN[0]<!>  = 1
+    platformJ[0]  = 1
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/assignToVar.fir.kt

@@ -0,0 +1,24 @@
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+    public static J staticJ;
+}
+
+// FILE: k.kt
+var v: J = J()
+var n: J? = J()
+
+fun test() {
+    v = J.staticNN
+    v = <!ASSIGNMENT_TYPE_MISMATCH!>J.staticN<!>
+    v = J.staticJ
+
+    n = J.staticNN
+    n = J.staticN
+    n = J.staticJ
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/conditions.fir.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static Boolean staticNN;
+    @MyNullable
+    public static Boolean staticN;
+    public static Boolean staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    val platformNN = J.staticNN
+    val platformN = J.staticN
+    val platformJ = J.staticJ
+
+    if (platformNN) {}
+    if (<!CONDITION_TYPE_MISMATCH!>platformN<!>) {}
+    if (platformJ) {}
+
+    while (platformNN) {}
+    while (<!CONDITION_TYPE_MISMATCH!>platformN<!>) {}
+    while (platformJ) {}
+
+    do {} while (platformNN)
+    do {} while (<!CONDITION_TYPE_MISMATCH!>platformN<!>)
+    do {} while (platformJ)
+
+    platformNN && false
+    <!CONDITION_TYPE_MISMATCH!>platformN<!> && false
+    platformJ && false
+
+    platformNN || false
+    <!CONDITION_TYPE_MISMATCH!>platformN<!> || false
+    platformJ || false
+
+    !platformNN
+    <!UNSAFE_CALL!>!<!>platformN
+    !platformJ
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/dataFlowInfo.fir.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+}
+
+// FILE: k.kt
+fun test() {
+    val n = J.staticN
+    foo(<!ARGUMENT_TYPE_MISMATCH!>n<!>)
+    J.staticNN = <!ASSIGNMENT_TYPE_MISMATCH!>n<!>
+    if (n != null) {
+        foo(n)
+        J.staticNN = n
+    }
+
+    val x: J? = null
+    J.staticNN = <!ASSIGNMENT_TYPE_MISMATCH!>x<!>
+    if (x != null) {
+        J.staticNN = x
+    }
+}
+
+fun foo(j: J) {}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/defaultParameters.fir.kt

@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+    public static J staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    val platformNN = J.staticNN
+    val platformN = J.staticN
+    val platformJ = J.staticJ
+
+    fun foo(p: J = platformNN, p1: J = platformN, p2: J = platformJ) {}
+
+    fun foo1(p: J? = platformNN, p1: J? = platformN, p2: J? = platformJ) {}
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegatedProperties.fir.kt

@@ -0,0 +1,21 @@
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+
+    public interface DP {
+        String getValue(Object a, Object b);
+        String setValue(Object a, Object b, Object c);
+    }
+
+    @MyNonnull
+    public static DP staticNN;
+    @MyNullable
+    public static DP staticN;
+    public static DP staticJ;
+}
+
+// FILE: k.kt
+var A by J.staticNN
+var B by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>J.staticN<!>
+var C by J.staticJ

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/delegation.fir.kt

@@ -0,0 +1,17 @@
+// JSR305_GLOBAL_REPORT: warn
+// FULL_JDK
+// FILE: J.java
+import java.util.*;
+
+public class J {
+    @MyNonnull
+    public static List<String> staticNN;
+    @MyNullable
+    public static List<String> staticN;
+    public static List<String> staticJ;
+}
+
+// FILE: k.kt
+class A : List<String> by J.staticNN
+class B : List<String> by J.staticN
+class C : List<String> by J.staticJ

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceExtension.fir.kt

@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+    public static J staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    val platformNN = J.staticNN
+    val platformN = J.staticN
+    val platformJ = J.staticJ
+
+    platformNN.foo()
+    platformN<!UNSAFE_CALL!>.<!>foo()
+    platformJ.foo()
+
+    with(platformNN) {
+        foo()
+    }
+    with(platformN) {
+        <!UNSAFE_CALL!>foo<!>()
+    }
+    with(platformJ) {
+        foo()
+    }
+
+    platformNN.bar()
+    platformN.bar()
+    platformJ.bar()
+}
+
+fun J.foo() {}
+fun J?.bar() {}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/derefenceMember.fir.kt

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+    public static J staticJ;
+
+    public void foo() {}
+}
+
+// FILE: k.kt
+fun test() {
+    // @NotNull platform type
+    val platformNN = J.staticNN
+    // @Nullable platform type
+    val platformN = J.staticN
+    // platform type with no annotation
+    val platformJ = J.staticJ
+
+    platformNN.foo()
+    platformN<!UNSAFE_CALL!>.<!>foo()
+    platformJ.foo()
+
+    with(platformNN) {
+        foo()
+    }
+    with(platformN) {
+        <!UNSAFE_CALL!>foo<!>()
+    }
+    with(platformJ) {
+        foo()
+    }
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/jsr305/nullabilityWarnings/fromPlatformTypes/expectedType.fir.kt

@@ -0,0 +1,26 @@
+// !CHECK_TYPE
+// JSR305_GLOBAL_REPORT: warn
+
+// FILE: J.java
+public class J {
+    @MyNonnull
+    public static J staticNN;
+    @MyNullable
+    public static J staticN;
+    public static J staticJ;
+}
+
+// FILE: k.kt
+fun test() {
+    val platformNN = J.staticNN
+    val platformN = J.staticN
+    val platformJ = J.staticJ
+
+    checkSubtype<J>(platformNN)
+    checkSubtype<J>(<!ARGUMENT_TYPE_MISMATCH!>platformN<!>)
+    checkSubtype<J>(platformJ)
+
+    checkSubtype<J?>(platformNN)
+    checkSubtype<J?>(platformN)
+    checkSubtype<J?>(platformJ)
+}