From 88a23c73c7223190818b2ce4ff5a474d781f94a4 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Thu, 8 Feb 2018 12:47:33 +0300 Subject: [PATCH] Ignore @Nullable annotation for vararg parameter See the comment in code for clarification #KT-19786 Fixed --- .../notNullVarargOverride.kt | 22 ++++++++++++++++ .../notNullVarargOverride.txt | 25 ++++++++++++++++++ .../nullableVarargOverride.kt | 22 ++++++++++++++++ .../nullableVarargOverride.txt | 25 ++++++++++++++++++ .../notNullVarargsOverrides.kt | 23 ++++++++++++++++ .../notNullVarargsOverrides.txt | 26 +++++++++++++++++++ .../nullableVarargsOverrides.kt | 23 ++++++++++++++++ .../nullableVarargsOverrides.txt | 26 +++++++++++++++++++ ...sNoAnnotationInClasspathTestGenerated.java | 12 +++++++++ ...pathWithFastClassReadingTestGenerated.java | 12 +++++++++ .../ForeignJava8AnnotationsTestGenerated.java | 12 +++++++++ ...cForeignJava8AnnotationsTestGenerated.java | 12 +++++++++ .../checkers/DiagnosticsTestGenerated.java | 12 +++++++++ .../DiagnosticsUsingJavacTestGenerated.java | 12 +++++++++ .../typeEnhancement/signatureEnhancement.kt | 10 ++++++- 15 files changed, 273 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.txt create mode 100644 compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.txt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.txt diff --git a/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt new file mode 100644 index 00000000000..338461c1433 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt @@ -0,0 +1,22 @@ +// FILE: BaseClass.java +import org.jetbrains.annotations.NotNull; + +public class BaseClass { + public void loadCache(@NotNull Object... args) {} +} + +// FILE: main.kt + +class A : BaseClass() { + // org.jetbrains.annotations.NotNull has @Target PARAMETER, so it doesn't affect elements type + override fun loadCache(vararg args: Any?) { + super.loadCache(*args) + } +} + +class B : BaseClass() { + // org.jetbrains.annotations.NotNull has @Target PARAMETER, so it doesn't affect elements type + override fun loadCache(vararg args: Any) { + super.loadCache(*args) + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.txt b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.txt new file mode 100644 index 00000000000..4c467d0cc90 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.txt @@ -0,0 +1,25 @@ +package + +public final class A : BaseClass { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B : BaseClass { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class BaseClass { + public constructor BaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun loadCache(/*0*/ @org.jetbrains.annotations.NotNull vararg args: kotlin.Any! /*kotlin.Array<(out) kotlin.Any!>*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt new file mode 100644 index 00000000000..6d130cdebff --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt @@ -0,0 +1,22 @@ +// FILE: BaseClass.java +import org.jetbrains.annotations.Nullable; + +public class BaseClass { + public void loadCache(@Nullable Object... args) {} +} + +// FILE: main.kt + +class A : BaseClass() { + // org.jetbrains.annotations.Nullable has @Target PARAMETER, so it doesn't affect elements type + override fun loadCache(vararg args: Any?) { + super.loadCache(*args) + } +} + +class B : BaseClass() { + // org.jetbrains.annotations.Nullable has @Target PARAMETER, so it doesn't affect elements type + override fun loadCache(vararg args: Any) { + super.loadCache(*args) + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.txt b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.txt new file mode 100644 index 00000000000..1829d5a2de1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.txt @@ -0,0 +1,25 @@ +package + +public final class A : BaseClass { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B : BaseClass { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class BaseClass { + public constructor BaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun loadCache(/*0*/ @org.jetbrains.annotations.Nullable vararg args: kotlin.Any! /*kotlin.Array<(out) kotlin.Any!>!*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt new file mode 100644 index 00000000000..71ceb91e4e7 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt @@ -0,0 +1,23 @@ +// JAVAC_EXPECTED_FILE +// SKIP_COMPILED_JAVA +// FILE: BaseClass.java +import org.checkerframework.checker.nullness.qual.*; + +public class BaseClass { + public void loadCache(@NonNull Object... args) {} +} + +// FILE: main.kt + +class A : BaseClass() { + // org.checkerframework.checker.nullness.qual.NonNull has @Target TYPE_USE, so it affects only elements type + override fun loadCache(vararg args: Any?) { + super.loadCache(*args) + } +} + +class B : BaseClass() { + override fun loadCache(vararg args: Any) { + super.loadCache(*args) + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.txt new file mode 100644 index 00000000000..e93bffc23b6 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.txt @@ -0,0 +1,26 @@ +package + +public final class A : BaseClass { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull vararg args: @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any>*/): kotlin.Unit + public open fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B : BaseClass { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class BaseClass { + public constructor BaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull vararg args: @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.NonNull kotlin.Any>*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt new file mode 100644 index 00000000000..91d1355bd7d --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt @@ -0,0 +1,23 @@ +// JAVAC_EXPECTED_FILE +// SKIP_COMPILED_JAVA +// FILE: BaseClass.java +import org.checkerframework.checker.nullness.qual.*; + +public class BaseClass { + public void loadCache(@Nullable Object... args) {} +} + +// FILE: main.kt + +class A : BaseClass() { + override fun loadCache(vararg args: Any?) { + super.loadCache(*args) + } +} + +class B : BaseClass() { + // org.checkerframework.checker.nullness.qual.Nullable has @Target TYPE_USE, so it affects only elements type + override fun loadCache(vararg args: Any) { + super.loadCache(*args) + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.txt new file mode 100644 index 00000000000..9b20edfe5cd --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.txt @@ -0,0 +1,26 @@ +package + +public final class A : BaseClass { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun loadCache(/*0*/ vararg args: kotlin.Any? /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B : BaseClass { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable vararg args: @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any? /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any?>!*/): kotlin.Unit + public open fun loadCache(/*0*/ vararg args: kotlin.Any /*kotlin.Array*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class BaseClass { + public constructor BaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun loadCache(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable vararg args: @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any? /*kotlin.Array<(out) @org.checkerframework.checker.nullness.qual.Nullable kotlin.Any?>!*/): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java index adbf65a1ee8..9d73faaaeab 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java @@ -102,6 +102,18 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends doTest(fileName); } + @TestMetadata("notNullVarargsOverrides.kt") + public void testNotNullVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargsOverrides.kt") + public void testNullableVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt"); + doTest(fileName); + } + @TestMetadata("returnTypeDifferentConstructor.kt") public void testReturnTypeDifferentConstructor() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java index b3150ce287e..d69b809b067 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java @@ -102,6 +102,18 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingT doTest(fileName); } + @TestMetadata("notNullVarargsOverrides.kt") + public void testNotNullVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargsOverrides.kt") + public void testNullableVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt"); + doTest(fileName); + } + @TestMetadata("returnTypeDifferentConstructor.kt") public void testReturnTypeDifferentConstructor() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java index cfe1a7396e5..77649f8f533 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java @@ -102,6 +102,18 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An doTest(fileName); } + @TestMetadata("notNullVarargsOverrides.kt") + public void testNotNullVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargsOverrides.kt") + public void testNullableVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt"); + doTest(fileName); + } + @TestMetadata("returnTypeDifferentConstructor.kt") public void testReturnTypeDifferentConstructor() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java index cf098869b95..f2a5d47058c 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -102,6 +102,18 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore doTest(fileName); } + @TestMetadata("notNullVarargsOverrides.kt") + public void testNotNullVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/notNullVarargsOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargsOverrides.kt") + public void testNullableVarargsOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/nullableVarargsOverrides.kt"); + doTest(fileName); + } + @TestMetadata("returnTypeDifferentConstructor.kt") public void testReturnTypeDifferentConstructor() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index a23c4f28e78..5dea44e4a87 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -13303,6 +13303,18 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("notNullVarargOverride.kt") + public void testNotNullVarargOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargOverride.kt") + public void testNullableVarargOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt"); + doTest(fileName); + } + @TestMetadata("overridesDefaultValue.kt") public void testOverridesDefaultValue() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesDefaultValue.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index e81979d2e8b..d592a257a8e 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -13303,6 +13303,18 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing doTest(fileName); } + @TestMetadata("notNullVarargOverride.kt") + public void testNotNullVarargOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt"); + doTest(fileName); + } + + @TestMetadata("nullableVarargOverride.kt") + public void testNullableVarargOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt"); + doTest(fileName); + } + @TestMetadata("overridesDefaultValue.kt") public void testOverridesDefaultValue() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesDefaultValue.kt"); diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 79812788796..745afe05123 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -195,6 +195,9 @@ class SignatureEnhancement( private val containerContext: LazyJavaResolverContext, private val containerApplicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType ) { + + private val isForVarargParameter get() = typeContainer.safeAs()?.varargElementType != null + fun enhance(predefined: TypeEnhancementInfo? = null): PartEnhancementResult { val qualifiers = computeIndexedQualifiersForOverride() @@ -352,7 +355,12 @@ class SignatureEnhancement( val ownNullabilityForWarning = own.nullability val isCovariantPosition = isCovariant && isHeadTypeConstructor - val nullability = nullabilityFromSupertypes.select(ownNullability, isCovariantPosition) + val nullability = + nullabilityFromSupertypes.select(ownNullability, isCovariantPosition) + // Vararg value parameters effectively have non-nullable type in Kotlin + // and having nullable types in Java may lead to impossibility of overriding them in Kotlin + ?.takeUnless { isForVarargParameter && isHeadTypeConstructor && it == NullabilityQualifier.NULLABLE } + val mutability = mutabilityFromSupertypes .select(MutabilityQualifier.MUTABLE, MutabilityQualifier.READ_ONLY, own.mutability, isCovariantPosition)