From f39e2d4a2d01c8321151590e7b88c50981aea91e Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 9 Oct 2020 14:55:17 +0300 Subject: [PATCH] JSpecify: convert java use sites for existing tests to kotlin ones --- .../strictMode/AnnotatedBoundsOfWildcard.kt | 59 ++++++++++++++++ .../strictMode/AnnotatedBoundsOfWildcard.txt | 46 +++++++++++++ .../jspecify/kotlin/strictMode/Defaults.kt | 22 ++++++ .../jspecify/kotlin/strictMode/Defaults.txt | 35 ++++++++++ .../kotlin/strictMode/IgnoreAnnotations.kt | 17 +++++ .../kotlin/strictMode/IgnoreAnnotations.txt | 41 +++++++++++ .../strictMode/NonPlatformTypeParameter.kt | 16 +++++ .../strictMode/NonPlatformTypeParameter.txt | 27 ++++++++ .../NullnessUnspecifiedTypeParameter.kt | 19 ++++++ .../NullnessUnspecifiedTypeParameter.txt | 27 ++++++++ .../jspecify/kotlin/strictMode/SelfType.kt | 21 ++++++ .../strictMode/SelfType.txt} | 47 ++++++------- .../jspecify/kotlin/strictMode/Simple.kt | 11 +++ .../jspecify/kotlin/strictMode/Simple.txt | 38 +++++++++++ .../TypeArgumentsFromParameterBounds.kt | 32 +++++++++ .../TypeArgumentsFromParameterBounds.txt | 51 ++++++++++++++ .../kotlin/strictMode/TypeParameterBounds.kt | 27 ++++++++ .../kotlin/strictMode/TypeParameterBounds.txt | 36 ++++++++++ .../kotlin/strictMode/WildcardsWithDefault.kt | 22 ++++++ .../strictMode/WildcardsWithDefault.txt | 29 ++++++++ .../warnMode/AnnotatedBoundsOfWildcard.kt | 60 ++++++++++++++++ .../warnMode/AnnotatedBoundsOfWildcard.txt | 46 +++++++++++++ .../jspecify/kotlin/warnMode/Defaults.kt | 23 +++++++ .../jspecify/kotlin/warnMode/Defaults.txt | 35 ++++++++++ .../kotlin/warnMode/IgnoreAnnotations.kt | 18 +++++ .../kotlin/warnMode/IgnoreAnnotations.txt | 41 +++++++++++ .../warnMode/NonPlatformTypeParameter.kt | 17 +++++ .../warnMode/NonPlatformTypeParameter.txt | 27 ++++++++ .../NullnessUnspecifiedTypeParameter.kt | 20 ++++++ .../NullnessUnspecifiedTypeParameter.txt | 27 ++++++++ .../jspecify/kotlin/warnMode/SelfType.kt | 22 ++++++ .../jspecify/kotlin/warnMode/SelfType.txt | 68 +++++++++++++++++++ .../tests/jspecify/kotlin/warnMode/Simple.kt | 12 ++++ .../tests/jspecify/kotlin/warnMode/Simple.txt | 38 +++++++++++ .../TypeArgumentsFromParameterBounds.kt | 33 +++++++++ .../TypeArgumentsFromParameterBounds.txt | 51 ++++++++++++++ .../kotlin/warnMode/TypeParameterBounds.kt | 28 ++++++++ .../kotlin/warnMode/TypeParameterBounds.txt | 36 ++++++++++ .../kotlin/warnMode/WildcardsWithDefault.kt | 23 +++++++ .../kotlin/warnMode/WildcardsWithDefault.txt | 29 ++++++++ 40 files changed, 1254 insertions(+), 23 deletions(-) create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.kt rename compiler/testData/foreignAnnotationsJava8/tests/jspecify/{selfType.txt => kotlin/strictMode/SelfType.txt} (76%) create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.txt diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.kt new file mode 100644 index 00000000000..ab1646a43cb --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.kt @@ -0,0 +1,59 @@ +// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java + +fun main( + aNotNullNotNullNotNull: Test, + aNotNullNotNullNull: Test, + aNotNullNullNotNull: Test, + aNotNullNullNull: Test, + + aAnyNotNullNotNullNotNull: Test, + aAnyNotNullNotNullNull: Test, + aAnyNotNullNullNotNull: Test, + aAnyNotNullNullNull: Test, + + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.txt new file mode 100644 index 00000000000..0ba07ebe427 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/AnnotatedBoundsOfWildcard.txt @@ -0,0 +1,46 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: Test, /*1*/ aNotNullNotNullNull: Test, /*2*/ aNotNullNullNotNull: Test, /*3*/ aNotNullNullNull: Test, /*4*/ aAnyNotNullNotNullNotNull: Test, /*5*/ aAnyNotNullNotNullNull: Test, /*6*/ aAnyNotNullNullNotNull: Test, /*7*/ aAnyNotNullNullNull: Test, /*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!): kotlin.Unit + public open fun extendsNotNull(/*0*/ a: Test!): kotlin.Unit + public open fun extendsNullable(/*0*/ a: Test!): 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!): kotlin.Unit + public open fun superNotNull(/*0*/ a: Test!): kotlin.Unit + public open fun superNullable(/*0*/ a: Test!): 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 { + 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 main(/*0*/ aNotNullNotNullNotNull: Test!, /*1*/ aNotNullNotNullNull: Test!, /*2*/ aNotNullNullNotNull: Test!, /*3*/ aNotNullNullNull: Test!, /*4*/ aObjectNotNullNotNullNotNull: Test!, /*5*/ aObjectNotNullNotNullNull: Test!, /*6*/ aObjectNotNullNullNotNull: Test!, /*7*/ aObjectNotNullNullNull: Test!, /*8*/ b: AnnotatedBoundsOfWildcard!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.kt new file mode 100644 index 00000000000..aa66a016549 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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(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() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Defaults.txt new file mode 100644 index 00000000000..475a05bc975 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.kt new file mode 100644 index 00000000000..6c101b71c0e --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.kt @@ -0,0 +1,17 @@ +// JAVA_SOURCES: IgnoreAnnotations.java + +fun main(a: IgnoreAnnotations, x: Derived): Unit { + 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() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/IgnoreAnnotations.txt new file mode 100644 index 00000000000..adc09d44aa4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.kt new file mode 100644 index 00000000000..25ce418f167 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.kt @@ -0,0 +1,16 @@ +// JAVA_SOURCES: NonPlatformTypeParameter.java + +fun main(a1: NonPlatformTypeParameter, a2: NonPlatformTypeParameter, x: T): Unit { + a1.foo(null) + a1.bar(null) + // jspecify_nullness_mismatch + a1.bar(null) + a1.bar(x) + + // jspecify_nullness_mismatch + a2.foo(null) + a2.bar(null) + // jspecify_nullness_mismatch + a2.bar(null) + a2.bar(x) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.txt new file mode 100644 index 00000000000..af5b22a05e4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NonPlatformTypeParameter.txt @@ -0,0 +1,27 @@ +package + +public fun main(/*0*/ a1: NonPlatformTypeParameter, /*1*/ a2: NonPlatformTypeParameter, /*2*/ x: T): kotlin.Unit + +public open class NonPlatformTypeParameter { + public constructor NonPlatformTypeParameter() + public open fun 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 main(/*0*/ a1: NonPlatformTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*1*/ a2: NonPlatformTypeParameter!, /*2*/ x: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.kt new file mode 100644 index 00000000000..ba384dabc66 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.kt @@ -0,0 +1,19 @@ +// JAVA_SOURCES: NullnessUnspecifiedTypeParameter.java + +fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter, x: Test): Unit { + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.txt new file mode 100644 index 00000000000..a305456702b --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/NullnessUnspecifiedTypeParameter.txt @@ -0,0 +1,27 @@ +package + +public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter, /*1*/ a2: NullnessUnspecifiedTypeParameter, /*2*/ x: Test): kotlin.Unit + +@org.jspecify.annotations.DefaultNonNull public open class NullnessUnspecifiedTypeParameter { + public constructor NullnessUnspecifiedTypeParameter() + 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!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.kt new file mode 100644 index 00000000000..e427fb8661e --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/selfType.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.txt similarity index 76% rename from compiler/testData/foreignAnnotationsJava8/tests/jspecify/selfType.txt rename to compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.txt index 0ddc94ba0d2..95df12f1732 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/selfType.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/SelfType.txt @@ -2,66 +2,67 @@ package public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit -public open class A> { - public constructor A>() - 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 final class AK : A { +public open class AK : SelfType { 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 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 final class AKN : A { +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: AK): kotlin.Unit + 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 : A { +public open class B : SelfType { 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 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 final class BK : B { +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 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> : A { - public constructor C>() +public open class C!> : SelfType { + public constructor C!>() 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 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 final class CK : C { +public open class CK : C { 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 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 final class CKN : C { +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: CK): kotlin.Unit + 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!> { + public constructor SelfType!>() + 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 } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.kt new file mode 100644 index 00000000000..3288245f2c9 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.kt @@ -0,0 +1,11 @@ +// JAVA_SOURCES: Simple.java + +fun main(a: Simple, x: Derived): Unit { + a.foo(x, null).foo() + // jspecify_nullness_mismatch + a.foo(null, x).foo() + + a.bar().foo() + + a.field.foo() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/Simple.txt new file mode 100644 index 00000000000..8a0a6c126b7 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.kt new file mode 100644 index 00000000000..ea06768b933 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.kt @@ -0,0 +1,32 @@ +// JAVA_SOURCES: TypeArgumentsFromParameterBounds.java + +fun main( + aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds, + aNotNullNotNullNull: TypeArgumentsFromParameterBounds, + aNotNullNullNotNull: TypeArgumentsFromParameterBounds, + aNotNullNullNull: TypeArgumentsFromParameterBounds, + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.txt new file mode 100644 index 00000000000..7b6bc297f09 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeArgumentsFromParameterBounds.txt @@ -0,0 +1,51 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds, /*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!): 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!): 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 { + public constructor TypeArgumentsFromParameterBounds() + 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!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.kt new file mode 100644 index 00000000000..e4edf982529 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.kt @@ -0,0 +1,27 @@ +// JAVA_SOURCES: TypeParameterBounds.java + +fun main(a1: A, a2: A, b1: B, b2: B, x: T): Unit { + // jspecify_nullness_mismatch + a1.foo(null) + // jspecify_nullness_mismatch + a1.bar(null) + a1.bar(x) + + // jspecify_nullness_mismatch + a2.foo(null) + // jspecify_nullness_mismatch + a2.bar(null) + a2.bar(x) + + // jspecify_nullness_mismatch + b1.foo(null) + // jspecify_nullness_mismatch + b1.bar(null) + b1.bar(x) + + // jspecify_nullness_mismatch + b2.foo(null) + // jspecify_nullness_mismatch + b2.bar(null) + b2.bar(x) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.txt new file mode 100644 index 00000000000..ef9f5dbda66 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/TypeParameterBounds.txt @@ -0,0 +1,36 @@ +package + +public fun main(/*0*/ a1: A, /*1*/ a2: A, /*2*/ b1: B, /*3*/ b2: B, /*4*/ x: T): kotlin.Unit + +@org.jspecify.annotations.DefaultNonNull public open class A { + public constructor A() + public open fun 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 { + public constructor B() + public open fun 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 main(/*0*/ a1: A<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*1*/ a2: A!, /*2*/ b1: B<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*3*/ b2: B!, /*4*/ x: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.kt new file mode 100644 index 00000000000..13155237aea --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.kt @@ -0,0 +1,22 @@ +// JAVA_SOURCES: WildcardsWithDefault.java + +fun main( + aNotNullNotNullNotNull: A, + aNotNullNotNullNull: A, + aNotNullNullNotNull: A, + aNotNullNullNull: A, + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.txt new file mode 100644 index 00000000000..75b527e8dc6 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode/WildcardsWithDefault.txt @@ -0,0 +1,29 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: A, /*1*/ aNotNullNotNullNull: A, /*2*/ aNotNullNullNotNull: A, /*3*/ aNotNullNullNull: A, /*4*/ b: WildcardsWithDefault): kotlin.Unit + +public open class A { + 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 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!, /*1*/ aNotNullNotNullNull: A!, /*2*/ aNotNullNullNotNull: A!, /*3*/ aNotNullNullNull: A!, /*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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.kt new file mode 100644 index 00000000000..7a9d98c1df6 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.kt @@ -0,0 +1,60 @@ +// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java +// JSPECIFY_STATE warn + +fun main( + aNotNullNotNullNotNull: Test, + aNotNullNotNullNull: Test, + aNotNullNullNotNull: Test, + aNotNullNullNull: Test, + + aAnyNotNullNotNullNotNull: Test, + aAnyNotNullNotNullNull: Test, + aAnyNotNullNullNotNull: Test, + aAnyNotNullNullNull: Test, + + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.txt new file mode 100644 index 00000000000..0ba07ebe427 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/AnnotatedBoundsOfWildcard.txt @@ -0,0 +1,46 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: Test, /*1*/ aNotNullNotNullNull: Test, /*2*/ aNotNullNullNotNull: Test, /*3*/ aNotNullNullNull: Test, /*4*/ aAnyNotNullNotNullNotNull: Test, /*5*/ aAnyNotNullNotNullNull: Test, /*6*/ aAnyNotNullNullNotNull: Test, /*7*/ aAnyNotNullNullNull: Test, /*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!): kotlin.Unit + public open fun extendsNotNull(/*0*/ a: Test!): kotlin.Unit + public open fun extendsNullable(/*0*/ a: Test!): 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!): kotlin.Unit + public open fun superNotNull(/*0*/ a: Test!): kotlin.Unit + public open fun superNullable(/*0*/ a: Test!): 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 { + 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 main(/*0*/ aNotNullNotNullNotNull: Test!, /*1*/ aNotNullNotNullNull: Test!, /*2*/ aNotNullNullNotNull: Test!, /*3*/ aNotNullNullNull: Test!, /*4*/ aObjectNotNullNotNullNotNull: Test!, /*5*/ aObjectNotNullNotNullNull: Test!, /*6*/ aObjectNotNullNullNotNull: Test!, /*7*/ aObjectNotNullNullNull: Test!, /*8*/ b: AnnotatedBoundsOfWildcard!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.kt new file mode 100644 index 00000000000..ecda36ec32d --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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(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() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Defaults.txt new file mode 100644 index 00000000000..475a05bc975 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.kt new file mode 100644 index 00000000000..a0c6b907a28 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.kt @@ -0,0 +1,18 @@ +// JAVA_SOURCES: IgnoreAnnotations.java +// JSPECIFY_STATE warn + +fun main(a: IgnoreAnnotations, x: Derived): Unit { + 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() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/IgnoreAnnotations.txt new file mode 100644 index 00000000000..adc09d44aa4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.kt new file mode 100644 index 00000000000..bc5c0ff7773 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.kt @@ -0,0 +1,17 @@ +// JAVA_SOURCES: NonPlatformTypeParameter.java +// JSPECIFY_STATE warn + +fun main(a1: NonPlatformTypeParameter, a2: NonPlatformTypeParameter, x: T): Unit { + a1.foo(null) + a1.bar(null) + // jspecify_nullness_mismatch + a1.bar(null) + a1.bar(x) + + // jspecify_nullness_mismatch + a2.foo(null) + a2.bar(null) + // jspecify_nullness_mismatch + a2.bar(null) + a2.bar(x) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.txt new file mode 100644 index 00000000000..af5b22a05e4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NonPlatformTypeParameter.txt @@ -0,0 +1,27 @@ +package + +public fun main(/*0*/ a1: NonPlatformTypeParameter, /*1*/ a2: NonPlatformTypeParameter, /*2*/ x: T): kotlin.Unit + +public open class NonPlatformTypeParameter { + public constructor NonPlatformTypeParameter() + public open fun 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 main(/*0*/ a1: NonPlatformTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*1*/ a2: NonPlatformTypeParameter!, /*2*/ x: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.kt new file mode 100644 index 00000000000..1840067a7ef --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.kt @@ -0,0 +1,20 @@ +// JAVA_SOURCES: NullnessUnspecifiedTypeParameter.java +// JSPECIFY_STATE warn + +fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter, x: Test): Unit { + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.txt new file mode 100644 index 00000000000..a305456702b --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/NullnessUnspecifiedTypeParameter.txt @@ -0,0 +1,27 @@ +package + +public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter, /*1*/ a2: NullnessUnspecifiedTypeParameter, /*2*/ x: Test): kotlin.Unit + +@org.jspecify.annotations.DefaultNonNull public open class NullnessUnspecifiedTypeParameter { + public constructor NullnessUnspecifiedTypeParameter() + 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!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.kt new file mode 100644 index 00000000000..b2375e4461f --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/SelfType.txt new file mode 100644 index 00000000000..95df12f1732 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 { + 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 { + 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!> : SelfType { + public constructor C!>() + 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 { + 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!> { + public constructor SelfType!>() + 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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.kt new file mode 100644 index 00000000000..42a08b816cd --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.kt @@ -0,0 +1,12 @@ +// JAVA_SOURCES: Simple.java +// JSPECIFY_STATE warn + +fun main(a: Simple, x: Derived): Unit { + a.foo(x, null).foo() + // jspecify_nullness_mismatch + a.foo(null, x).foo() + + a.bar().foo() + + a.field.foo() +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/Simple.txt new file mode 100644 index 00000000000..8a0a6c126b7 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/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 +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.kt new file mode 100644 index 00000000000..a1dae2b46cf --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.kt @@ -0,0 +1,33 @@ +// JAVA_SOURCES: TypeArgumentsFromParameterBounds.java +// JSPECIFY_STATE warn + +fun main( + aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds, + aNotNullNotNullNull: TypeArgumentsFromParameterBounds, + aNotNullNullNotNull: TypeArgumentsFromParameterBounds, + aNotNullNullNull: TypeArgumentsFromParameterBounds, + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.txt new file mode 100644 index 00000000000..7b6bc297f09 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeArgumentsFromParameterBounds.txt @@ -0,0 +1,51 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds, /*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!): 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!): 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 { + public constructor TypeArgumentsFromParameterBounds() + 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!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.kt new file mode 100644 index 00000000000..18ad46b3bed --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.kt @@ -0,0 +1,28 @@ +// JAVA_SOURCES: TypeParameterBounds.java +// JSPECIFY_STATE warn + +fun main(a1: A, a2: A, b1: B, b2: B, x: T): Unit { + // jspecify_nullness_mismatch + a1.foo(null) + // jspecify_nullness_mismatch + a1.bar(null) + a1.bar(x) + + // jspecify_nullness_mismatch + a2.foo(null) + // jspecify_nullness_mismatch + a2.bar(null) + a2.bar(x) + + // jspecify_nullness_mismatch + b1.foo(null) + // jspecify_nullness_mismatch + b1.bar(null) + b1.bar(x) + + // jspecify_nullness_mismatch + b2.foo(null) + // jspecify_nullness_mismatch + b2.bar(null) + b2.bar(x) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.txt new file mode 100644 index 00000000000..ef9f5dbda66 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/TypeParameterBounds.txt @@ -0,0 +1,36 @@ +package + +public fun main(/*0*/ a1: A, /*1*/ a2: A, /*2*/ b1: B, /*3*/ b2: B, /*4*/ x: T): kotlin.Unit + +@org.jspecify.annotations.DefaultNonNull public open class A { + public constructor A() + public open fun 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 { + public constructor B() + public open fun 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 main(/*0*/ a1: A<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*1*/ a2: A!, /*2*/ b1: B<@org.jspecify.annotations.Nullable kotlin.Any!>!, /*3*/ b2: B!, /*4*/ x: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.kt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.kt new file mode 100644 index 00000000000..eeb88cdf08a --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.kt @@ -0,0 +1,23 @@ +// JAVA_SOURCES: WildcardsWithDefault.java +// JSPECIFY_STATE warn + +fun main( + aNotNullNotNullNotNull: A, + aNotNullNotNullNull: A, + aNotNullNullNotNull: A, + aNotNullNullNull: A, + 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) +} \ No newline at end of file diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.txt b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.txt new file mode 100644 index 00000000000..75b527e8dc6 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode/WildcardsWithDefault.txt @@ -0,0 +1,29 @@ +package + +public fun main(/*0*/ aNotNullNotNullNotNull: A, /*1*/ aNotNullNotNullNull: A, /*2*/ aNotNullNullNotNull: A, /*3*/ aNotNullNullNull: A, /*4*/ b: WildcardsWithDefault): kotlin.Unit + +public open class A { + 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 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!, /*1*/ aNotNullNotNullNull: A!, /*2*/ aNotNullNullNotNull: A!, /*3*/ aNotNullNullNull: A!, /*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 +}