[Test] Migrate tests of foreign annotations to new infrastructure

This commit includes:
- test runners for foreign annotation tests
- minor changes testdata related to changed directives syntax
- dropping tests with javac integration: old javac tests actually ran
    compiler without javac because of bug in configuration, so some
    nullability annotations features are not supported in javac mode.
    It's fine to drop it since javac mode is not fully supported
    by compiler

compiler/testData/foreignAnnotations/java8Tests/checkerFramework.kt

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

compiler/testData/foreignAnnotations/java8Tests/checkerFramework.txt

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

compiler/testData/foreignAnnotations/java8Tests/eclipse.kt

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

compiler/testData/foreignAnnotations/java8Tests/eclipse.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/AnnotatedBoundsOfWildcard.java

@@ -0,0 +1,81 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super @NullnessUnspecified Base, ? super @NullnessUnspecified 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 @NullnessUnspecified Base, ? extends @NullnessUnspecified 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<@NullnessUnspecified ?, @NullnessUnspecified ?, @NullnessUnspecified ?> a) {}
+}
+
+class Base {}
+class Derived extends Base {}
+
+@DefaultNonNull
+class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+@DefaultNonNull
+class Use {
+    public void main(
+            Test<Derived, Derived, Derived> aNotNullNotNullNotNull,
+            Test<Derived, Derived, @Nullable Derived> aNotNullNotNullNull,
+            Test<Derived, @Nullable Derived, Derived> aNotNullNullNotNull,
+            Test<Derived, @Nullable Derived, @Nullable Derived> aNotNullNullNull,
+
+            Test<Object, Object, Object> aObjectNotNullNotNullNotNull,
+            Test<Object, Object, @Nullable Object> aObjectNotNullNotNullNull,
+            Test<Object, @Nullable Object, Object> aObjectNotNullNullNotNull,
+            Test<Object, @Nullable Object, @Nullable Object> aObjectNotNullNullNull,
+
+            AnnotatedBoundsOfWildcard b
+    ) {
+        // jspecify_nullness_mismatch
+        b.superAsIs(aObjectNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        b.superAsIs(aObjectNotNullNotNullNull);
+        b.superAsIs(aObjectNotNullNullNotNull);
+        b.superAsIs(aObjectNotNullNullNull);
+
+        b.superNotNull(aObjectNotNullNotNullNotNull);
+        b.superNotNull(aObjectNotNullNotNullNull);
+        b.superNotNull(aObjectNotNullNullNotNull);
+        b.superNotNull(aObjectNotNullNullNull);
+
+        // jspecify_nullness_mismatch
+        b.superNullable(aObjectNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        b.superNullable(aObjectNotNullNotNullNull);
+        // jspecify_nullness_mismatch
+        b.superNullable(aObjectNotNullNullNotNull);
+        // jspecify_nullness_mismatch
+        b.superNullable(aObjectNotNullNullNull);
+
+        b.extendsAsIs(aNotNullNotNullNotNull);
+        b.extendsAsIs(aNotNullNotNullNull);
+        b.extendsAsIs(aNotNullNullNotNull);
+        b.extendsAsIs(aNotNullNullNull);
+
+        b.extendsNotNull(aNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        b.extendsNotNull(aNotNullNotNullNull);
+        // jspecify_nullness_mismatch
+        b.extendsNotNull(aNotNullNullNotNull);
+        // jspecify_nullness_mismatch
+        b.extendsNotNull(aNotNullNullNull);
+
+        b.extendsNullable(aNotNullNotNullNotNull);
+        b.extendsNullable(aNotNullNotNullNull);
+        b.extendsNullable(aNotNullNullNotNull);
+        b.extendsNullable(aNotNullNullNull);
+
+        b.noBounds(aNotNullNotNullNotNull);
+        b.noBounds(aNotNullNotNullNull);
+        b.noBounds(aNotNullNullNotNull);
+        b.noBounds(aNotNullNullNull);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/Defaults.java

@@ -0,0 +1,44 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+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; }
+}
+
+class Foo {
+    public Object foo() { return null; }
+}
+
+class Use {
+    static void main(Defaults a, Foo x) {
+        // jspecify_nullness_mismatch
+        a.everythingNotNullable(null).foo();
+        a.everythingNotNullable(x).foo();
+
+        a.everythingNullable(null).foo();
+
+        a.everythingUnknown(null).foo();
+
+        // jspecify_nullness_mismatch
+        a.mixed(null).foo();
+        a.mixed(x).foo();
+
+        a.explicitlyNullnessUnspecified(x).foo();
+        a.explicitlyNullnessUnspecified(null).foo();
+
+        a.defaultField.foo();
+
+        a.field.foo();
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/IgnoreAnnotations.java

@@ -0,0 +1,41 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+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; }
+}
+
+class Base {
+    void foo() {}
+}
+
+class Derived extends Base { }
+
+class Use {
+    static void main(IgnoreAnnotations a, Derived x) {
+        a.foo(x, null).foo();
+        // jspecify_nullness_mismatch
+        a.foo(null, x).foo();
+
+        a.field.foo();
+
+        // jspecify_nullness_mismatch
+        a.everythingNotNullable(null).foo();
+        a.everythingNotNullable(x).foo();
+
+        a.everythingNullable(null).foo();
+
+        a.everythingUnknown(null).foo();
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/NonPlatformTypeParameter.java

@@ -0,0 +1,26 @@
+import org.jspecify.annotations.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+class Test {}
+
+@DefaultNonNull
+class Use {
+    public <T extends Test> void main(NonPlatformTypeParameter<@Nullable Object> a1, NonPlatformTypeParameter<Test> a2, T x) {
+        a1.foo(null);
+        a1.<@Nullable Test>bar(null);
+        // jspecify_nullness_mismatch
+        a1.<T>bar(null);
+        a1.<T>bar(x);
+
+        // jspecify_nullness_mismatch
+        a2.foo(null);
+        a2.<@Nullable Test>bar(null);
+        // jspecify_nullness_mismatch
+        a2.<T>bar(null);
+        a2.<T>bar(x);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/NullnessUnspecifiedTypeParameter.java

@@ -0,0 +1,30 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+class Test {}
+
+class Use {
+    void main(NullnessUnspecifiedTypeParameter<Object> a1, NullnessUnspecifiedTypeParameter<@Nullable Object> a2, Test x) {
+        a1.foo(null);
+        a1.foo(1);
+
+        a2.foo(null);
+        a2.foo(1);
+
+        // jspecify_nullness_mismatch
+        a1.bar(null, null);
+        a1.bar(x, null);
+        a1.bar(x, 1);
+
+        // jspecify_nullness_mismatch
+        a2.bar(null, null);
+        a2.bar(x, null);
+        a2.bar(x, 1);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/SelfType.java

@@ -0,0 +1,40 @@
+import org.jspecify.annotations.*;
+
+@DefaultNotNull
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+class B extends SelfType<B> {}
+
+@DefaultNotNull
+class C<E extends C<E>> extends SelfType<E> {}
+
+class AK extends SelfType<AK> {}
+class AKN extends SelfType<@Nullable AK> {}
+
+class BK extends B {}
+
+class CK extends C<CK> {}
+
+class CKN extends C<@Nullable CK> {
+    public void main(AK ak, AKN akn, BK bk, CK ck, CKN ckn) {
+        ak.foo(ak);
+        // jspecify_nullness_mismatch
+        ak.foo(null);
+
+        // jspecify_nullness_mismatch
+        akn.foo(null);
+
+        bk.foo(bk);
+        // jspecify_nullness_mismatch
+        bk.foo(null);
+
+        ck.foo(ck);
+        // jspecify_nullness_mismatch
+        ck.foo(null);
+
+        // jspecify_nullness_mismatch
+        ckn.foo(null);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/Simple.java

@@ -0,0 +1,33 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+class Base {}
+class Derived extends Base {
+    void foo() {}
+}
+
+@DefaultNonNull
+class Use {
+    static public void main(Simple a, Derived x) {
+        a.foo(x, null).foo();
+        // jspecify_nullness_mismatch
+        a.foo(null, x).foo();
+
+        a.bar().foo();
+
+        a.field.foo();
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/TypeArgumentsFromParameterBounds.java

@@ -0,0 +1,53 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+class A {
+    public void bar(TypeArgumentsFromParameterBounds<@Nullable Test, @Nullable Test, @Nullable Test> a) {}
+}
+
+@DefaultNonNull
+class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+class C {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+class Test {}
+
+@DefaultNonNull
+class Use {
+    static public void main(
+            TypeArgumentsFromParameterBounds<Test, Test, Test> aNotNullNotNullNotNull,
+            TypeArgumentsFromParameterBounds<Test, Test, @Nullable Test> aNotNullNotNullNull,
+            TypeArgumentsFromParameterBounds<Test, @Nullable Test, Test> aNotNullNullNotNull,
+            TypeArgumentsFromParameterBounds<Test, @Nullable Test, @Nullable Test> aNotNullNullNull,
+            A a, B b, C c
+    ) {
+        // jspecify_nullness_mismatch
+        a.bar(aNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        a.bar(aNotNullNotNullNull);
+        // jspecify_nullness_mismatch
+        a.bar(aNotNullNullNotNull);
+        a.bar(aNotNullNullNull);
+
+        b.bar(aNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        b.bar(aNotNullNotNullNull);
+        // jspecify_nullness_mismatch
+        b.bar(aNotNullNullNotNull);
+        // jspecify_nullness_mismatch
+        b.bar(aNotNullNullNull);
+
+        // jspecify_nullness_mismatch
+        c.bar(aNotNullNotNullNotNull);
+        // jspecify_nullness_mismatch
+        c.bar(aNotNullNotNullNull);
+        c.bar(aNotNullNullNotNull);
+        c.bar(aNotNullNullNull);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/TypeParameterBounds.java

@@ -0,0 +1,44 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+@DefaultNonNull
+class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+class Test {}
+
+@DefaultNonNull
+public class TypeParameterBounds {
+    <T extends Test> void main(A<@Nullable Object> a1, A<Test> a2, B<@Nullable Object> b1, B<Test> b2, T x) {
+        // jspecify_nullness_mismatch
+        a1.foo(null);
+        // jspecify_nullness_mismatch
+        a1.<@Nullable T>bar(null);
+        a1.<T>bar(x);
+
+        // jspecify_nullness_mismatch
+        a2.foo(null);
+        // jspecify_nullness_mismatch
+        a2.<@Nullable T>bar(null);
+        a2.<T>bar(x);
+
+        // jspecify_nullness_mismatch
+        b1.foo(null);
+        // jspecify_nullness_mismatch
+        b1.<@Nullable T>bar(null);
+        b1.<T>bar(x);
+
+        // jspecify_nullness_mismatch
+        b2.foo(null);
+        // jspecify_nullness_mismatch
+        b2.<@Nullable T>bar(null);
+        b2.<T>bar(x);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/java/WildcardsWithDefault.java

@@ -0,0 +1,33 @@
+import org.jspecify.annotations.*;
+
+@DefaultNonNull
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<@Nullable ?, @Nullable ?, @Nullable ?> a) {}
+}
+
+class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+@DefaultNonNull
+class Use {
+    public static void main(
+            A<Object, Object, Object> aNotNullNotNullNotNull,
+            A<Object, Object, @Nullable Object> aNotNullNotNullNull,
+            A<Object, @Nullable Object, Object> aNotNullNullNotNull,
+            A<Object, @Nullable Object, @Nullable Object> aNotNullNullNull,
+            WildcardsWithDefault b
+    ) {
+        // jspecify_nullness_mismatch
+        b.noBoundsNotNull(aNotNullNotNullNotNull);
+        b.noBoundsNotNull(aNotNullNotNullNull);
+        // jspecify_nullness_mismatch
+        b.noBoundsNotNull(aNotNullNullNotNull);
+        // jspecify_nullness_mismatch
+        b.noBoundsNotNull(aNotNullNullNull);
+
+        b.noBoundsNullable(aNotNullNotNullNotNull);
+        b.noBoundsNullable(aNotNullNotNullNull);
+        b.noBoundsNullable(aNotNullNullNotNull);
+        b.noBoundsNullable(aNotNullNullNull);
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.kt

@@ -0,0 +1,59 @@
+// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java
+
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNull)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/Defaults.kt

@@ -0,0 +1,22 @@
+// JAVA_SOURCES: Defaults.java
+
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/Defaults.txt

@@ -0,0 +1,35 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.annotations.DefaultNonNull public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo!
+    @org.jspecify.annotations.Nullable public final var field: @org.jspecify.annotations.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Foo!): Foo!
+    @org.jspecify.annotations.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.annotations.Nullable x: @org.jspecify.annotations.Nullable Foo!): @org.jspecify.annotations.Nullable Foo!
+    @org.jspecify.annotations.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.annotations.NullnessUnspecified x: @org.jspecify.annotations.NullnessUnspecified Foo!): @org.jspecify.annotations.NullnessUnspecified Foo!
+    public open fun explicitlyNullnessUnspecified(/*0*/ @org.jspecify.annotations.NullnessUnspecified x: @org.jspecify.annotations.NullnessUnspecified Foo!): Foo!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.annotations.Nullable public open fun mixed(/*0*/ x: Foo!): @org.jspecify.annotations.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public/*package*/ open fun main(/*0*/ a: Defaults!, /*1*/ x: Foo!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/IgnoreAnnotations.kt

@@ -0,0 +1,17 @@
+// JAVA_SOURCES: IgnoreAnnotations.java
+
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/IgnoreAnnotations.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.kt

@@ -0,0 +1,16 @@
+// JAVA_SOURCES: NonPlatformTypeParameter.java
+
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.kt

@@ -0,0 +1,19 @@
+// JAVA_SOURCES: NullnessUnspecifiedTypeParameter.java
+
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit {
+    a1.foo(null)
+    a1.foo(1)
+
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.txt

@@ -0,0 +1,27 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.annotations.DefaultNonNull public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!>()
+    public open fun bar(/*0*/ s: Test!, /*1*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public/*package*/ open fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any!>!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/SelfType.kt

@@ -0,0 +1,21 @@
+// JAVA_SOURCES: SelfType.java
+
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/SelfType.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/Simple.kt

@@ -0,0 +1,11 @@
+// JAVA_SOURCES: Simple.java
+
+fun main(a: Simple, x: Derived): Unit {
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/Simple.txt

@@ -0,0 +1,38 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Simple {
+    public constructor Simple()
+    @org.jspecify.annotations.Nullable public final var field: @org.jspecify.annotations.Nullable Derived!
+    public open fun bar(): Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.annotations.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.annotations.NullnessUnspecified y: @org.jspecify.annotations.NullnessUnspecified Base!): @org.jspecify.annotations.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ a: Simple!, /*1*/ x: Derived!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.kt

@@ -0,0 +1,32 @@
+// JAVA_SOURCES: TypeArgumentsFromParameterBounds.java
+
+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, c: C
+): Unit {
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    a.bar(aNotNullNullNull)
+
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    c.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    c.bar(aNotNullNotNullNull)
+    c.bar(aNotNullNullNotNull)
+    c.bar(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.txt

@@ -0,0 +1,51 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B, /*6*/ c: C): kotlin.Unit
+
+public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<@org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class C {
+    public constructor C()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test!, Test!, @org.jspecify.annotations.Nullable Test!>!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.annotations.Nullable Test!, Test!>!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!>!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/TypeParameterBounds.kt

@@ -0,0 +1,27 @@
+// JAVA_SOURCES: TypeParameterBounds.java
+
+fun <T : Test> main(a1: A<Any?>, a2: A<Test>, b1: B<Any?>, b2: B<Test>, x: T): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/TypeParameterBounds.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/WildcardsWithDefault.kt

@@ -0,0 +1,22 @@
+// JAVA_SOURCES: WildcardsWithDefault.java
+
+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 {
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/strictMode/WildcardsWithDefault.txt

@@ -0,0 +1,29 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any!, kotlin.Any!, kotlin.Any!>!, /*1*/ aNotNullNotNullNull: A<kotlin.Any!, kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ aNotNullNullNotNull: A<kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!, kotlin.Any!>!, /*3*/ aNotNullNullNull: A<kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!>!, /*4*/ b: WildcardsWithDefault!): kotlin.Unit
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBoundsNotNull(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.kt

@@ -0,0 +1,60 @@
+// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java
+// JSPECIFY_STATE warn
+
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(aNotNullNullNull)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/Defaults.kt

@@ -0,0 +1,23 @@
+// JAVA_SOURCES: Defaults.java
+// JSPECIFY_STATE warn
+
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/Defaults.txt

@@ -0,0 +1,35 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.annotations.DefaultNonNull public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo!
+    @org.jspecify.annotations.Nullable public final var field: @org.jspecify.annotations.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Foo!): Foo!
+    @org.jspecify.annotations.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.annotations.Nullable x: @org.jspecify.annotations.Nullable Foo!): @org.jspecify.annotations.Nullable Foo!
+    @org.jspecify.annotations.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.annotations.NullnessUnspecified x: @org.jspecify.annotations.NullnessUnspecified Foo!): @org.jspecify.annotations.NullnessUnspecified Foo!
+    public open fun explicitlyNullnessUnspecified(/*0*/ @org.jspecify.annotations.NullnessUnspecified x: @org.jspecify.annotations.NullnessUnspecified Foo!): Foo!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.annotations.Nullable public open fun mixed(/*0*/ x: Foo!): @org.jspecify.annotations.Nullable Foo!
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public/*package*/ open fun main(/*0*/ a: Defaults!, /*1*/ x: Foo!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/IgnoreAnnotations.kt

@@ -0,0 +1,18 @@
+// JAVA_SOURCES: IgnoreAnnotations.java
+// JSPECIFY_STATE warn
+
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/IgnoreAnnotations.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.kt

@@ -0,0 +1,17 @@
+// JAVA_SOURCES: NonPlatformTypeParameter.java
+// JSPECIFY_STATE warn
+
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.kt

@@ -0,0 +1,20 @@
+// JAVA_SOURCES: NullnessUnspecifiedTypeParameter.java
+// JSPECIFY_STATE warn
+
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit {
+    a1.foo(null)
+    a1.foo(1)
+
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.txt

@@ -0,0 +1,27 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.annotations.DefaultNonNull public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any!>()
+    public open fun bar(/*0*/ s: Test!, /*1*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public/*package*/ open fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any!>!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/SelfType.kt

@@ -0,0 +1,22 @@
+// JAVA_SOURCES: SelfType.java
+// JSPECIFY_STATE warn
+
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/SelfType.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/Simple.kt

@@ -0,0 +1,12 @@
+// JAVA_SOURCES: Simple.java
+// JSPECIFY_STATE warn
+
+fun main(a: Simple, x: Derived): Unit {
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/Simple.txt

@@ -0,0 +1,38 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Simple {
+    public constructor Simple()
+    @org.jspecify.annotations.Nullable public final var field: @org.jspecify.annotations.Nullable Derived!
+    public open fun bar(): Derived!
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.annotations.Nullable public open fun foo(/*0*/ x: Derived!, /*1*/ @org.jspecify.annotations.NullnessUnspecified y: @org.jspecify.annotations.NullnessUnspecified Base!): @org.jspecify.annotations.Nullable Derived!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ a: Simple!, /*1*/ x: Derived!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.kt

@@ -0,0 +1,33 @@
+// JAVA_SOURCES: TypeArgumentsFromParameterBounds.java
+// JSPECIFY_STATE warn
+
+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, c: C
+): Unit {
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    a.bar(aNotNullNullNull)
+
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    c.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    c.bar(aNotNullNotNullNull)
+    c.bar(aNotNullNullNotNull)
+    c.bar(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.txt

@@ -0,0 +1,51 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B, /*6*/ c: C): kotlin.Unit
+
+public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<@org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class C {
+    public constructor C()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test!, Test!, @org.jspecify.annotations.Nullable Test!>!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.annotations.Nullable Test!, Test!>!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.annotations.Nullable Test!, @org.jspecify.annotations.Nullable Test!>!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/TypeParameterBounds.kt

@@ -0,0 +1,28 @@
+// JAVA_SOURCES: TypeParameterBounds.java
+// JSPECIFY_STATE warn
+
+fun <T : Test> main(a1: A<Any?>, a2: A<Test>, b1: B<Any?>, b2: B<Test>, x: T): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/TypeParameterBounds.txt

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

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/WildcardsWithDefault.kt

@@ -0,0 +1,23 @@
+// JAVA_SOURCES: WildcardsWithDefault.java
+// JSPECIFY_STATE warn
+
+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 {
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/foreignAnnotations/java8Tests/jspecify/kotlin/warnMode/WildcardsWithDefault.txt

@@ -0,0 +1,29 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E : @org.jspecify.annotations.Nullable kotlin.Any!, /*2*/ F : @org.jspecify.annotations.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class Use {
+    public constructor Use()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any!, kotlin.Any!, kotlin.Any!>!, /*1*/ aNotNullNotNullNull: A<kotlin.Any!, kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ aNotNullNullNotNull: A<kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!, kotlin.Any!>!, /*3*/ aNotNullNullNull: A<kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!, @org.jspecify.annotations.Nullable kotlin.Any!>!, /*4*/ b: WildcardsWithDefault!): kotlin.Unit
+}
+
+@org.jspecify.annotations.DefaultNonNull public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBoundsNotNull(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/jsr305/defaultAnnotationAppliedToType.kt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/defaultAnnotationAppliedToType.txt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.txt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/springNullableWithTypeUse.kt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/springNullableWithTypeUse.txt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/typeArguments.kt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/typeArguments.txt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/typeUseVsMethodConflict.kt

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

compiler/testData/foreignAnnotations/java8Tests/jsr305/typeUseVsMethodConflict.txt

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

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/annotatedTypeArguments.javac.txt

@@ -0,0 +1,66 @@
+package
+
+public/*package*/ open class AnnotatedTypeArguments {
+    public/*package*/ constructor AnnotatedTypeArguments()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun foo(/*0*/ x: L<P<L<kotlin.String!>!, S<*>!>!>!): L<P<L<kotlin.String!>!, S<*>!>!>!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : AnnotatedTypeArguments.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>): @org.checkerframework.checker.nullness.qual.Nullable L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : AnnotatedTypeArguments.B {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<kotlin.String?>, S<*>>!>): L<P<L<kotlin.String?>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D1 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D1()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>): L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D2 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D2()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable L<P<L<kotlin.String?>, S<*>>!>!): @org.checkerframework.checker.nullness.qual.NonNull L<P<L<kotlin.String?>, S<*>>!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public/*package*/ interface L</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface P</*0*/ X : kotlin.Any!, /*1*/ Y : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface S</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/annotatedTypeArguments.kt

@@ -0,0 +1,39 @@
+// JAVAC_EXPECTED_FILE
+// FILE: AnnotatedTypeArguments.java
+
+import org.checkerframework.checker.nullness.qual.*;
+
+interface P<X, Y> {}
+interface L<T> {}
+interface S<T> {}
+
+class AnnotatedTypeArguments {
+
+    class A {
+        L<P<L<String>, S<?>>> foo(L<P<L<String>, S<?>>> x) {return null;}
+    }
+
+    class B extends A {
+        // some complicated type tree
+        // return type and argument's type differ only by nullability of outermost type
+        @Nullable
+        L<P<@NonNull L<@Nullable String>, @NonNull S<?>>> foo(@NonNull L<P<@NonNull L<@Nullable String>, @NonNull S<?>>> x) {return null;}
+    }
+
+    class C extends B {
+        // signature should be the same as in A
+        L<P<L<String>, S<?>>> foo(L<P<L<String>, S<?>>> x) {return null;}
+    }
+
+    class D1 extends C {
+        // signature should be the same as in A, but annotated String-type should be platform
+        L<P<L<@NonNull String>, S<?>>> foo(L<P<L<@NonNull String>, S<?>>> x) {return null;}
+    }
+
+    class D2 extends C {
+        // return type refined to not-nullable
+        // argument type here same as in A except outermost type (it becomes flexible because of conflict)
+        @NonNull
+        L<P<L<String>, S<?>>> foo(@Nullable L<P<L<String>, S<?>>> x) {return null;}
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/annotatedTypeArguments.txt

@@ -0,0 +1,48 @@
+package
+
+public/*package*/ open class AnnotatedTypeArguments {
+    public/*package*/ constructor AnnotatedTypeArguments()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun foo(/*0*/ x: L<P<L<kotlin.String!>!, S<*>!>!>!): L<P<L<kotlin.String!>!, S<*>!>!>!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : AnnotatedTypeArguments.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>): @org.checkerframework.checker.nullness.qual.Nullable L<P<@org.checkerframework.checker.nullness.qual.NonNull L<@org.checkerframework.checker.nullness.qual.Nullable kotlin.String?>, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : AnnotatedTypeArguments.B {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<kotlin.String?>, S<*>>!>): L<P<L<kotlin.String?>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D1 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D1()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open override /*1*/ fun foo(/*0*/ x: L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>): L<P<L<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>, S<*>>!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D2 : AnnotatedTypeArguments.C {
+        public/*package*/ constructor D2()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable L<P<L<kotlin.String?>, S<*>>!>!): @org.checkerframework.checker.nullness.qual.NonNull L<P<L<kotlin.String?>, S<*>>!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/methodWithTypeParameter.javac.txt

@@ -0,0 +1,56 @@
+package
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public/*package*/ open fun </*0*/ T : kotlin.Any!> bar(/*0*/ x: Y<T!>!): X<T!>!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun </*0*/ K : kotlin.Any!, /*1*/ V : kotlin.Any!> foo(/*0*/ x: K!): V!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun </*0*/ R : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull Y<@org.checkerframework.checker.nullness.qual.NonNull R>): @org.checkerframework.checker.nullness.qual.Nullable X<@org.checkerframework.checker.nullness.qual.Nullable R!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ T1 : kotlin.Any!, /*1*/ T2 : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable T1?): @org.checkerframework.checker.nullness.qual.NonNull T2
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.B {
+        public/*package*/ constructor C()
+        @java.lang.Override public/*package*/ open override /*1*/ fun </*0*/ E : kotlin.Any!> bar(/*0*/ x: Y<E>): X<E!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun </*0*/ I : kotlin.Any!, /*1*/ J : kotlin.Any!> foo(/*0*/ x: I?): J
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.C {
+        public/*package*/ constructor D()
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ F : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable Y<@org.checkerframework.checker.nullness.qual.Nullable F!>!): @org.checkerframework.checker.nullness.qual.NonNull X<@org.checkerframework.checker.nullness.qual.NonNull F!>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ U : kotlin.Any!, /*1*/ W : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable U?): @org.checkerframework.checker.nullness.qual.NonNull W
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public/*package*/ interface X</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface Y</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/methodWithTypeParameter.kt

@@ -0,0 +1,55 @@
+// JAVAC_EXPECTED_FILE
+// FILE: Outer.java
+
+import org.checkerframework.checker.nullness.qual.*;
+
+interface X<T> {}
+interface Y<T> {}
+
+class Outer {
+    class A {
+        <K, V> V foo(K x) { return null; }
+
+        <T> X<T> bar(Y<T> x) { return null; }
+    }
+
+    class B extends A {
+        // OK, non-platform types
+        @Override
+        @NonNull
+        <T1, T2> T2 foo(@Nullable T1 x) { return null; }
+
+        // Parameter type is fully non-flexible (OK)
+        // Return type is `X<R!>?`.
+        // The reason is that we do not treat it as equal to return type of A.bar because they are base on different type parameters,
+        // so type enhancing happens only for outermost type.
+        // TODO: We should properly compare equality with specific local equality axioms (as when calculating overriden descriptors)
+        @Override
+        @Nullable
+        <R> X<@Nullable R> bar(@NonNull Y<@NonNull R> x) { return null; }
+    }
+
+    class C extends B {
+        // OK, non-platform types
+        @Override
+        <I, J> J foo(I x) { return null; }
+
+        // Parameter type is fully non-flexible (OK)
+        // Return type is `X<R!>?`, same is in B
+        @Override
+        <E> X<E> bar(Y<E> x) { return null; }
+    }
+
+    class D extends C {
+        // Return type is not-nullable, covariantly overridden, OK
+        // Parameter type is flexible, because of conflict with supertype, OK
+        @Override
+        @NonNull
+        <U, W> W foo(@Nullable U x) { return null; }
+
+
+        @Override
+        @NonNull
+        <F> X<@NonNull F> bar(@Nullable Y<@Nullable F> x) { return null; }
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/methodWithTypeParameter.txt

@@ -0,0 +1,44 @@
+package
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public/*package*/ open fun </*0*/ T : kotlin.Any!> bar(/*0*/ x: Y<T!>!): X<T!>!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public/*package*/ open fun </*0*/ K : kotlin.Any!, /*1*/ V : kotlin.Any!> foo(/*0*/ x: K!): V!
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun </*0*/ R : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull Y<@org.checkerframework.checker.nullness.qual.NonNull R>): @org.checkerframework.checker.nullness.qual.Nullable X<@org.checkerframework.checker.nullness.qual.Nullable R!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ T1 : kotlin.Any!, /*1*/ T2 : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable T1?): @org.checkerframework.checker.nullness.qual.NonNull T2
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.B {
+        public/*package*/ constructor C()
+        @java.lang.Override public/*package*/ open override /*1*/ fun </*0*/ E : kotlin.Any!> bar(/*0*/ x: Y<E>): X<E!>?
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun </*0*/ I : kotlin.Any!, /*1*/ J : kotlin.Any!> foo(/*0*/ x: I?): J
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.C {
+        public/*package*/ constructor D()
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ F : kotlin.Any!> bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable Y<@org.checkerframework.checker.nullness.qual.Nullable F!>!): @org.checkerframework.checker.nullness.qual.NonNull X<@org.checkerframework.checker.nullness.qual.NonNull F!>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun </*0*/ U : kotlin.Any!, /*1*/ W : kotlin.Any!> foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable U?): @org.checkerframework.checker.nullness.qual.NonNull W
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/notNullVarargsOverrides.kt

@@ -0,0 +1,22 @@
+// 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
+    <!NOTHING_TO_OVERRIDE!>override<!> fun loadCache(vararg args: Any?) {
+        super.loadCache(*<!TYPE_MISMATCH!>args<!>)
+    }
+}
+
+class B : BaseClass() {
+    override fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/notNullVarargsOverrides.txt

@@ -0,0 +1,26 @@
+package
+
+public final class A : BaseClass {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull vararg args: @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any>*/): kotlin.Unit
+    public open fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array<out kotlin.Any?>*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B : BaseClass {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array<out kotlin.Any>*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BaseClass {
+    public constructor BaseClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull vararg args: @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any>*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/nullableVarargsOverrides.kt

@@ -0,0 +1,22 @@
+// 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
+    <!NOTHING_TO_OVERRIDE!>override<!> fun loadCache(vararg args: Any) {
+        super.loadCache(*args)
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/nullableVarargsOverrides.txt

@@ -0,0 +1,26 @@
+package
+
+public final class A : BaseClass {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array<out kotlin.Any?>*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B : BaseClass {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable vararg args: @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any? /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any?>!*/): kotlin.Unit
+    public open fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array<out kotlin.Any>*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BaseClass {
+    public constructor BaseClass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable vararg args: @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any? /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any?>!*/): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/returnTypeDifferentConstructor.javac.txt

@@ -0,0 +1,68 @@
+package
+
+public/*package*/ interface Base</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ interface Derived</*0*/ E : kotlin.Any!> : Base<E!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Base<kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.A {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Base<kotlin.String>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.A {
+        public/*package*/ constructor D()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class E : Outer.A {
+        public/*package*/ constructor E()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class F : Outer.A {
+        public/*package*/ constructor F()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/returnTypeDifferentConstructor.kt

@@ -0,0 +1,38 @@
+// JAVAC_EXPECTED_FILE
+// FILE: Outer.java
+
+import org.checkerframework.checker.nullness.qual.*;
+
+interface Base<T> {}
+interface Derived<E> extends Base<E> {}
+
+class Outer {
+    class A {
+        @Nullable Base<@NonNull String> foo() { return null; }
+    }
+
+    class B extends A {
+        @Override
+        Base<String> foo() { return null; }
+    }
+
+    class C extends A {
+        @Override
+        @NonNull Base<String> foo() { return null; }
+    }
+
+    class D extends A {
+        @Override
+        Derived<String> foo() { return null; }
+    }
+
+    class E extends A {
+        @Override
+        @NonNull Derived<String> foo() { return null; }
+    }
+
+    class F extends A {
+        @Override
+        @NonNull Derived<@NonNull String> foo() { return null; }
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/returnTypeDifferentConstructor.txt

@@ -0,0 +1,56 @@
+package
+
+public/*package*/ open class Outer {
+    public/*package*/ constructor Outer()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public/*package*/ open inner class A {
+        public/*package*/ constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class B : Outer.A {
+        public/*package*/ constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Base<kotlin.String>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class C : Outer.A {
+        public/*package*/ constructor C()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Base<kotlin.String>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class D : Outer.A {
+        public/*package*/ constructor D()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Derived<kotlin.String!>?
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class E : Outer.A {
+        public/*package*/ constructor E()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public/*package*/ open inner class F : Outer.A {
+        public/*package*/ constructor F()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!>
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/returnTypeOverrideInKotlin.kt

@@ -0,0 +1,33 @@
+// 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(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Derived<String?><!> { return bar2(); }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/returnTypeOverrideInKotlin.txt

@@ -0,0 +1,56 @@
+package
+
+public fun bar1(): Derived<kotlin.String>
+public fun bar2(): Derived<kotlin.String?>
+
+public open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B : A {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    protected open override /*1*/ fun foo(): Base<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Base</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C1 : A {
+    public constructor C1()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    protected open override /*1*/ fun foo(): Derived<kotlin.String>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C2 : A {
+    public constructor C2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    protected open override /*1*/ fun foo(): Derived<kotlin.String>?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C3 : A {
+    public constructor C3()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    protected open override /*1*/ fun foo(): Derived<kotlin.String?>
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Derived</*0*/ E> : Base<E> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/simple.kt

@@ -0,0 +1,8 @@
+// FILE: A.java
+
+import org.checkerframework.checker.nullness.qual.*;
+import java.util.*;
+
+class A {
+    List<@NonNull String> foo() { return null; }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancement/simple.txt

@@ -0,0 +1,9 @@
+package
+
+public/*package*/ open class A {
+    public/*package*/ constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.collections.(Mutable)List<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.java

@@ -0,0 +1,6 @@
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBound <T extends @NotNull String> {
+    ClassTypeParameterBound(T x) { }
+    ClassTypeParameterBound() { }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+fun main(x: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>, y: ClassTypeParameterBound<String>, a: String?, b: String) {
+    val x2 = ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>>()
+    val y2 = ClassTypeParameterBound<String>()
+
+    val x3 = ClassTypeParameterBound(<!TYPE_MISMATCH!>a<!>)
+    val y3 = ClassTypeParameterBound(b)
+
+    val x4: ClassTypeParameterBound<<!UPPER_BOUND_VIOLATED!>String?<!>> = <!TYPE_MISMATCH!>ClassTypeParameterBound()<!>
+    val y4: ClassTypeParameterBound<String> = ClassTypeParameterBound()
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.java

@@ -0,0 +1,6 @@
+import org.jetbrains.annotations.NotNull;
+
+public class ClassTypeParameterBoundWithWarnings <T extends @NotNull String> {
+    ClassTypeParameterBoundWithWarnings() { }
+    ClassTypeParameterBoundWithWarnings(T x) { }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// SKIP_TXT
+
+// TODO: report warnings "UPPER_BOUND_VIOLATED"
+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/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ReturnType.java

@@ -0,0 +1,13 @@
+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; }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ReturnType.kt

@@ -0,0 +1,48 @@
+// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+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?>) {}
+
+// FILE: main.kt
+fun <R> main(a: ReturnType<R>) {
+    val x1 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.Nullable R?>..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.Nullable R?>?)")!>a.foo1()<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String, TypeVariable(K)>", "ReturnType.A<String?, R?>!")!>x1<!>)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(<!TYPE_MISMATCH!>a.foo41.foo411<!>)
+
+    val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull R!!>..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo2()<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x2<!>)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String, TypeVariable(K)>", "ReturnType.A<String?, R!!>!")!>x2<!>)
+    takeNullableStringAndNotNullK(x2)
+
+    val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnType.A<@org.jetbrains.annotations.NotNull kotlin.String, @org.jetbrains.annotations.NotNull R!!>..ReturnType.A<@org.jetbrains.annotations.NotNull kotlin.String, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo3<!>
+    takeNotNullStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndKNullable(<!TYPE_MISMATCH!>x3<!>)
+    takeNotNullStringAndNotNullK(x3)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH("ReturnType.A<String?, TypeVariable(K)>", "ReturnType.A<String, R!!>!")!>x3<!>)
+
+    val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<@org.jetbrains.annotations.NotNull R!!>..kotlin.Array<out @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo4<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(x4)
+    takeArrayOfNullableK(<!TYPE_MISMATCH!>x4<!>)
+
+    val x5 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>..kotlin.Array<out @org.jetbrains.annotations.Nullable kotlin.String?>?)")!>a.foo5()<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(x5)
+    takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(x5)
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.java

@@ -0,0 +1,13 @@
+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; }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt

@@ -0,0 +1,48 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// SKIP_TXT
+
+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?>) {}
+
+// FILE: main.kt
+fun <R> main(a: ReturnTypeWithWarnings<R>) {
+    val x1 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.Nullable R..@org.jetbrains.annotations.Nullable R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.Nullable R..@org.jetbrains.annotations.Nullable R?)>?)")!>a.foo1()<!>
+    takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String?, R?>!")!>x1<!>)
+    takeNullableStringAndKNullable(x1)
+    takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String?, R?>!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x1<!>)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x1<!>)
+    takeNotNullString(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("String", "String?")!>a.foo41.foo411<!>)
+
+    val x2 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo2()<!>
+    takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
+    takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>", "ReturnTypeWithWarnings.A<String?, R!!>!")!>x2<!>)
+    takeNotNullStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R!!>", "ReturnTypeWithWarnings.A<String?, R!!>!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x2<!>)
+    takeNullableStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x2<!>)
+
+    val x3 = <!DEBUG_INFO_EXPRESSION_TYPE("(ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.NotNull kotlin.String..@org.jetbrains.annotations.NotNull kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.NotNull kotlin.String..@org.jetbrains.annotations.NotNull kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo3<!>
+    takeNotNullStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String, R?>", "ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
+    takeNullableStringAndKNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R?>", "ReturnTypeWithWarnings.A<String, R!!>!")!>x3<!>)
+    takeNotNullStringAndNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x3<!>)
+    takeNullableStringAndNotNullK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("ReturnTypeWithWarnings.A<String?, R!!>", "ReturnTypeWithWarnings.A<String, R!!>!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x3<!>)
+
+    val x4 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<(@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>..kotlin.Array<out (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>)")!>a.foo4<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableString(<!TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNotNullK(<!TYPE_MISMATCH, TYPE_MISMATCH!>x4<!>)
+    takeArrayOfNullableK(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS("Array<R?>", "Array<(out) R!!>")!>x4<!>)
+
+    val x5 = <!DEBUG_INFO_EXPRESSION_TYPE("(kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?)>?..kotlin.Array<out (@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?)>?)")!>a.foo5()<!>
+    takeArrayOfNotNullString(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableString(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNotNullK(<!TYPE_MISMATCH!>x5<!>)
+    takeArrayOfNullableK(<!TYPE_MISMATCH!>x5<!>)
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ValueParameter.java

@@ -0,0 +1,13 @@
+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) { }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ValueParameter.kt

@@ -0,0 +1,45 @@
+// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS
+// SKIP_TXT
+
+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?>
+
+// FILE: main.kt
+fun <R> main(a: ValueParameter<R>) {
+    a.foo1(<!TYPE_MISMATCH!>getNotNullStringAndKNullable()<!>)
+    a.foo1(getNullableStringAndKNullable())
+    a.foo1(<!TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo1(<!TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo2(<!TYPE_MISMATCH!>getNotNullStringAndKNullable()<!>)
+    a.foo2(<!TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo2(<!TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo2(getNullableStringAndNotNullK())
+
+    a.foo3(<!TYPE_MISMATCH!>getNotNullStringAndKNullable()<!>)
+    a.foo3(<!TYPE_MISMATCH!>getNullableStringAndKNullable()<!>)
+    a.foo3(getNotNullStringAndNotNullK())
+    a.foo3(<!TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo4(<!TYPE_MISMATCH!>getArrayOfNotNullString()<!>)
+    a.foo4(<!TYPE_MISMATCH!>getArrayOfNullableString()<!>)
+    a.foo4(getArrayOfNotNullK())
+    a.foo4(<!TYPE_MISMATCH!>getArrayOfNullableK()<!>)
+
+    a.foo5(getArrayOfNotNullString())
+    a.foo5(getArrayOfNullableString())
+    a.foo5(getArrayOfNotNullK())
+    a.foo5(getArrayOfNullableK())
+
+    a.foo41(getNotNullString())
+    a.foo411(<!TYPE_MISMATCH!>getNotNullString()<!>)
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.java

@@ -0,0 +1,13 @@
+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) { }
+}

compiler/testData/foreignAnnotations/java8Tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt

@@ -0,0 +1,45 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS
+// SKIP_TXT
+
+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?>
+
+// FILE: main.kt
+fun <R> main(a: ValueParameterWithWarnings<R>) {
+    a.foo1(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getNotNullStringAndKNullable()<!>)
+    a.foo1(getNullableStringAndKNullable())
+    a.foo1(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo1(<!TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getNotNullStringAndKNullable()<!>)
+    a.foo2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getNullableStringAndKNullable()<!>)
+    a.foo2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo2(<!TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo3(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getNotNullStringAndKNullable()<!>)
+    a.foo3(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getNullableStringAndKNullable()<!>)
+    a.foo3(<!TYPE_MISMATCH!>getNotNullStringAndNotNullK()<!>)
+    a.foo3(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS, TYPE_MISMATCH!>getNullableStringAndNotNullK()<!>)
+
+    a.foo4(<!TYPE_MISMATCH!>getArrayOfNotNullString()<!>)
+    a.foo4(<!TYPE_MISMATCH!>getArrayOfNullableString()<!>)
+    a.foo4(getArrayOfNotNullK())
+    a.foo4(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>getArrayOfNullableK()<!>)
+
+    a.foo5(getArrayOfNotNullString())
+    a.foo5(getArrayOfNullableString())
+    a.foo5(getArrayOfNotNullK())
+    a.foo5(getArrayOfNullableK())
+
+    a.foo41(getNotNullString())
+    a.foo411(<!TYPE_MISMATCH!>getNotNullString()<!>)
+}

compiler/testData/foreignAnnotations/java8Tests/typeUseOnObject.kt

@@ -0,0 +1,17 @@
+// FILE: A.java
+import org.checkerframework.checker.nullness.qual.*;
+public class A {
+    @NonNull
+    public Object foo() { return null; }
+}
+// FILE: B.java
+public class B {
+    public static void assertNonNull(Object x) {}
+}
+
+// FILE: main.kt
+
+fun main() {
+    A()
+    B.assertNonNull(null)
+}

compiler/testData/foreignAnnotations/java8Tests/typeUseOnObject.txt

@@ -0,0 +1,21 @@
+package
+
+public fun main(): kotlin.Unit
+
+public open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.checkerframework.checker.nullness.qual.NonNull public open fun foo(): @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    // Static members
+    public open fun assertNonNull(/*0*/ x: kotlin.Any!): kotlin.Unit
+}