From 7dd9ed7e38ebdc7ccb69fe78ba42f3a1bfc58fe7 Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Thu, 21 Nov 2019 18:25:57 +0100 Subject: [PATCH] [NI] Fix loosing type annotations on extension functions #KT-32138 fixed --- .../fir/FirDiagnosticsSmokeTestGenerated.java | 10 +++++++++ .../jvm/JvmDeclarationReturnTypeSanitizer.kt | 8 ++++--- ...32189returnTypeWithTypealiasSubtitution.kt | 22 +++++++++++++++++++ ...2189returnTypeWithTypealiasSubtitution.txt | 21 ++++++++++++++++++ ...ypeWithTypealiasSubtitutionOldInference.kt | 22 +++++++++++++++++++ ...peWithTypealiasSubtitutionOldInference.txt | 21 ++++++++++++++++++ .../checkers/DiagnosticsTestGenerated.java | 10 +++++++++ .../DiagnosticsUsingJavacTestGenerated.java | 10 +++++++++ .../descriptors/annotations/Annotations.kt | 9 +++++++- ...32189returnTypeWithTypealiasSubtitution.kt | 19 ++++++++++++++++ .../checkers/PsiCheckerTestGenerated.java | 5 +++++ 11 files changed, 153 insertions(+), 4 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt create mode 100644 compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.txt create mode 100644 compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt create mode 100644 compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.txt create mode 100644 idea/testData/checker/kt32189returnTypeWithTypealiasSubtitution.kt diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java index 62035795f91..25f46a73033 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirDiagnosticsSmokeTestGenerated.java @@ -11030,6 +11030,16 @@ public class FirDiagnosticsSmokeTestGenerated extends AbstractFirDiagnosticsSmok runTest("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); } + @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") + public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt"); + } + + @TestMetadata("kt32189returnTypeWithTypealiasSubtitutionOldInference.kt") + public void testKt32189returnTypeWithTypealiasSubtitutionOldInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt"); + } + @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") public void testKt6081SubstituteIntoClassCorrectly() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDeclarationReturnTypeSanitizer.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDeclarationReturnTypeSanitizer.kt index c5a0dabc741..08a1e800d7c 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDeclarationReturnTypeSanitizer.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmDeclarationReturnTypeSanitizer.kt @@ -35,9 +35,11 @@ object JvmDeclarationReturnTypeSanitizer : DeclarationReturnTypeSanitizer { if (languageVersionSettings.supportsFeature(LanguageFeature.StrictJavaNullabilityAssertions)) { // NB can't check for presence of EnhancedNullability here, // because it will also cause recursion in declaration type resolution. - inferred.replaceAnnotations(FilteredAnnotations(inferred.annotations) { - it != JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION - }) + inferred.replaceAnnotations( + FilteredAnnotations(inferred.annotations, languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) { + it != JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION + } + ) } else inferred } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt new file mode 100644 index 00000000000..d4b9306ab8f --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt @@ -0,0 +1,22 @@ +// !LANGUAGE: +NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER + +class B { + class Builder +} + +typealias ApplyRestrictions = B.Builder.() -> B.Builder + +fun applyRestrictions1(): ApplyRestrictions = TODO() +fun applyRestrictions2() = applyRestrictions1() +fun applyRestrictions3(e: K) = applyRestrictions1() + +fun buildB() { + val a1 = applyRestrictions1() + val a2 = applyRestrictions2() + val a3 = applyRestrictions3("foo") + + B.Builder().a1() + B.Builder().a2() + B.Builder().a3() +} diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.txt b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.txt new file mode 100644 index 00000000000..1bef2a6997b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.txt @@ -0,0 +1,21 @@ +package + +public fun applyRestrictions1(): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun applyRestrictions2(): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun applyRestrictions3(/*0*/ e: K): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun buildB(): kotlin.Unit + +public final class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class Builder { + public constructor Builder() + 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 typealias ApplyRestrictions = B.Builder.() -> B.Builder diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt new file mode 100644 index 00000000000..924cbc007bc --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt @@ -0,0 +1,22 @@ +// !LANGUAGE: -NewInference +// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER + +class B { + class Builder +} + +typealias ApplyRestrictions = B.Builder.() -> B.Builder + +fun applyRestrictions1(): ApplyRestrictions = TODO() +fun applyRestrictions2() = applyRestrictions1() +fun applyRestrictions3(e: K) = applyRestrictions1() + +fun buildB() { + val a1 = applyRestrictions1() + val a2 = applyRestrictions2() + val a3 = applyRestrictions3("foo") + + B.Builder().a1() + B.Builder().a2() + B.Builder().a3() +} diff --git a/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.txt b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.txt new file mode 100644 index 00000000000..1bef2a6997b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.txt @@ -0,0 +1,21 @@ +package + +public fun applyRestrictions1(): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun applyRestrictions2(): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun applyRestrictions3(/*0*/ e: K): ApplyRestrictions /* = B.Builder.() -> B.Builder */ +public fun buildB(): kotlin.Unit + +public final class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class Builder { + public constructor Builder() + 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 typealias ApplyRestrictions = B.Builder.() -> B.Builder diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 08f8ad2612f..5b2d8637185 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -11037,6 +11037,16 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { runTest("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); } + @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") + public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt"); + } + + @TestMetadata("kt32189returnTypeWithTypealiasSubtitutionOldInference.kt") + public void testKt32189returnTypeWithTypealiasSubtitutionOldInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt"); + } + @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") public void testKt6081SubstituteIntoClassCorrectly() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 956e0e6a37e..0020f48e281 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -11032,6 +11032,16 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); } + @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") + public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt"); + } + + @TestMetadata("kt32189returnTypeWithTypealiasSubtitutionOldInference.kt") + public void testKt32189returnTypeWithTypealiasSubtitutionOldInference() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt"); + } + @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") public void testKt6081SubstituteIntoClassCorrectly() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt index e9720f3988b..44a5838c22b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/Annotations.kt @@ -51,9 +51,12 @@ interface Annotations : Iterable { class FilteredAnnotations( private val delegate: Annotations, + private val isDefinitelyNewInference: Boolean, private val fqNameFilter: (FqName) -> Boolean ) : Annotations { + constructor(delegate: Annotations, fqNameFilter: (FqName) -> Boolean) : this(delegate, false, fqNameFilter) + override fun hasAnnotation(fqName: FqName) = if (fqNameFilter(fqName)) delegate.hasAnnotation(fqName) else false @@ -64,7 +67,11 @@ class FilteredAnnotations( override fun iterator() = delegate.filter(this::shouldBeReturned).iterator() - override fun isEmpty() = delegate.any(this::shouldBeReturned) + override fun isEmpty(): Boolean { + val condition = delegate.any(this::shouldBeReturned) + // fixing KT-32189 && KT-32138 for the new inference only + return if (isDefinitelyNewInference) !condition else condition + } private fun shouldBeReturned(annotation: AnnotationDescriptor): Boolean = annotation.fqName.let { fqName -> diff --git a/idea/testData/checker/kt32189returnTypeWithTypealiasSubtitution.kt b/idea/testData/checker/kt32189returnTypeWithTypealiasSubtitution.kt new file mode 100644 index 00000000000..8bbd0255ebe --- /dev/null +++ b/idea/testData/checker/kt32189returnTypeWithTypealiasSubtitution.kt @@ -0,0 +1,19 @@ +class B { + class Builder +} + +typealias ApplyRestrictions = B.Builder.() -> B.Builder + +fun applyRestrictions1(): ApplyRestrictions = { this } +fun applyRestrictions2() = applyRestrictions1() +fun applyRestrictions3(e: K) = applyRestrictions1() + +fun buildB() { + val a1 = applyRestrictions1() + val a2 = applyRestrictions2() + val a3 = applyRestrictions3("foo") + + B.Builder().a1() + B.Builder().a2() + B.Builder().a3() +} diff --git a/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java index 6d0ee168af1..8feac7f25bb 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java @@ -155,6 +155,11 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { runTest("idea/testData/checker/JvmStaticUsagesRuntime.kt"); } + @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") + public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { + runTest("idea/testData/checker/kt32189returnTypeWithTypealiasSubtitution.kt"); + } + @TestMetadata("LocalObjects.kt") public void testLocalObjects() throws Exception { runTest("idea/testData/checker/LocalObjects.kt");