Generate foreign annotation test data for FIR

2021-07-29 15:38:53 +02:00
parent 5873511f64
commit 33251f6d50
154 changed files with 9029 additions and 8 deletions
@@ -0,0 +1,80 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: AnnotatedBoundsOfWildcard.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    b.superAsIs(aAnyNotNullNotNullNotNull)
+    b.superAsIs(aAnyNotNullNotNullNull)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    b.superNullable(aAnyNotNullNotNullNotNull)
+    b.superNullable(aAnyNotNullNotNullNull)
+    b.superNullable(aAnyNotNullNullNotNull)
+    b.superNullable(aAnyNotNullNullNull)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    b.extendsNotNull(aNotNullNotNullNull)
+    b.extendsNotNull(aNotNullNullNotNull)
+    b.extendsNotNull(aNotNullNullNull)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // JSPECIFY_STATE: warn
 // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode
 // FILE: J1.java
@@ -0,0 +1,45 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Defaults.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+// FILE: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}
@@ -0,0 +1,43 @@
+// JSPECIFY_STATE: warn
+
+// FILE: IgnoreAnnotations.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}
@@ -0,0 +1,27 @@
+// JSPECIFY_STATE: warn
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: NonPlatformTypeParameter.java
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}
@@ -0,0 +1,30 @@
+// JSPECIFY_STATE: warn
+// FILE: NullnessUnspecifiedTypeParameter.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit {
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}
@@ -0,0 +1,54 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>) // the corresponding warning/error is present on the Java side
+
+    bk.foo(bk)
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    ck.foo(null)
+
+    ckn.foo(null) // the corresponding warning/error is present on the Java side
+}
@@ -0,0 +1,36 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Simple.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}
@@ -0,0 +1,45 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    a.bar(aNotNullNotNullNull)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    a.bar(<!ARGUMENT_TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.bar(aNotNullNotNullNotNull)
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}
@@ -0,0 +1,39 @@
+// JSPECIFY_STATE: warn
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: A<Any?>, a2: A<Test>, b1: B<Any?>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}
@@ -0,0 +1,35 @@
+// JSPECIFY_STATE: warn
+// MUTE_FOR_PSI_CLASS_FILES_READING
+
+// FILE: WildcardsWithDefault.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    b.noBoundsNotNull(aNotNullNotNullNull)
+    b.noBoundsNotNull(aNotNullNullNotNull)
+    b.noBoundsNotNull(aNotNullNullNull)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}
@@ -0,0 +1,15 @@
+// JSPECIFY_STATE: warn
+
+// FILE: Foo.java
+import org.jspecify.nullness.Nullable;
+
+public class Foo {
+    public static <T> void gauge(@Nullable T stateObject) {}
+}
+
+// FILE: main.kt
+fun <T> test(metric: T) {
+    if (metric is String) {
+        Foo.gauge(metric)
+    }
+}