JSpecify: rework tests – replace kotlin use sites to java ones with future j2k conversion

2020-10-09 14:52:36 +03:00
parent 8974128be4
commit 520e35baaf
45 changed files with 425 additions and 1211 deletions
@@ -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);
+    }
+}
@@ -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();
+    }
+}
@@ -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();
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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();
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}
@@ -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);
+    }
+}