From 7781413a93cf79479a1caf860e2ac4a4689479f2 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 22 Feb 2022 13:15:59 +0300 Subject: [PATCH] FE 1.0: report TYPE_VARIANCE_CONFLICT also on qualifier type arguments #KT-51439 Fixed --- ...CompilerTestFE10TestdataTestGenerated.java | 12 +++++ ...irOldFrontendDiagnosticsTestGenerated.java | 12 +++++ ...DiagnosticsWithLightTreeTestGenerated.java | 12 +++++ .../jetbrains/kotlin/diagnostics/Errors.java | 2 + .../rendering/DefaultErrorMessages.java | 3 ++ .../kotlin/resolve/LazyTopDownAnalyzer.kt | 2 +- .../jetbrains/kotlin/resolve/TypeBinding.kt | 44 +++++++++++++------ .../kotlin/resolve/VarianceChecker.kt | 19 +++++++- .../tests/inner/typeVarianceConflict.fir.kt | 23 ++++++++++ .../tests/inner/typeVarianceConflict.kt | 23 ++++++++++ .../tests/inner/typeVarianceConflict.txt | 41 +++++++++++++++++ .../inner/typeVarianceConflictFeatureOn.kt | 12 +++++ .../inner/typeVarianceConflictFeatureOn.txt | 23 ++++++++++ .../test/runners/DiagnosticTestGenerated.java | 12 +++++ .../kotlin/config/LanguageVersionSettings.kt | 1 + 15 files changed, 224 insertions(+), 17 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inner/typeVarianceConflict.fir.kt create mode 100644 compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt create mode 100644 compiler/testData/diagnostics/tests/inner/typeVarianceConflict.txt create mode 100644 compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt create mode 100644 compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.txt diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index dbd90e9b516..4f496aaf363 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -17448,6 +17448,18 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); } + @Test + @TestMetadata("typeVarianceConflict.kt") + public void testTypeVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt"); + } + + @Test + @TestMetadata("typeVarianceConflictFeatureOn.kt") + public void testTypeVarianceConflictFeatureOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt"); + } + @Test @TestMetadata("visibility.kt") public void testVisibility() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 52487b4e638..bcb462053e8 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -17448,6 +17448,18 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); } + @Test + @TestMetadata("typeVarianceConflict.kt") + public void testTypeVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt"); + } + + @Test + @TestMetadata("typeVarianceConflictFeatureOn.kt") + public void testTypeVarianceConflictFeatureOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt"); + } + @Test @TestMetadata("visibility.kt") public void testVisibility() throws Exception { diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index a68aa2f137e..a1fd7db1d8e 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -17448,6 +17448,18 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); } + @Test + @TestMetadata("typeVarianceConflict.kt") + public void testTypeVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt"); + } + + @Test + @TestMetadata("typeVarianceConflictFeatureOn.kt") + public void testTypeVarianceConflictFeatureOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt"); + } + @Test @TestMetadata("visibility.kt") public void testVisibility() throws Exception { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index f7e573d2be4..5688907cf89 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -199,6 +199,8 @@ public interface Errors { DiagnosticFactory1.create(WARNING, VARIANCE_IN_PROJECTION); DiagnosticFactory1 TYPE_VARIANCE_CONFLICT = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT); + DiagnosticFactory1 TYPE_VARIANCE_CONFLICT_WARNING = + DiagnosticFactory1.create(WARNING, DECLARATION_SIGNATURE_OR_DEFAULT); DiagnosticFactory1 TYPE_VARIANCE_CONFLICT_IN_EXPANDED_TYPE = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT); DiagnosticFactory0 FINITE_BOUNDS_VIOLATION = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 02dfdb06a9d..596b6df0f0f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -807,6 +807,9 @@ public class DefaultErrorMessages { }; MAP.put(TYPE_VARIANCE_CONFLICT, "Type parameter {0} is declared as ''{1}'' but occurs in ''{2}'' position in type {3}", varianceConflictDataRenderer); + MAP.put(TYPE_VARIANCE_CONFLICT_WARNING, "Type parameter {0} is declared as ''{1}'' but occurs in ''{2}'' position in type {3}. " + + "This diagnostic will become an error soon. See https://youtrack.jetbrains.com/issue/KT-50947", + varianceConflictDataRenderer); MAP.put(TYPE_VARIANCE_CONFLICT_IN_EXPANDED_TYPE, "Type parameter {0} is declared as ''{1}'' but occurs in ''{2}'' position in abbreviated type {3}", varianceConflictDataRenderer); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt index 01be3bc3ce9..1b01a57e005 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.kt @@ -218,7 +218,7 @@ class LazyTopDownAnalyzer( overrideResolver.check(c) - varianceChecker.check(c) + varianceChecker.check(c, languageVersionSettings) declarationResolver.resolveAnnotationsOnFiles(c, fileScopeProvider) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt index cbecff90f79..ad39e89ea20 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.psi.KtCallableDeclaration import org.jetbrains.kotlin.psi.KtTypeElement import org.jetbrains.kotlin.psi.KtTypeReference +import org.jetbrains.kotlin.psi.KtUserType import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.types.* @@ -30,6 +31,7 @@ interface TypeBinding { val type: KotlinType val isInAbbreviation: Boolean val arguments: List?> + val isArgumentFromQualifier: Boolean get() = false } interface TypeArgumentBinding { @@ -44,15 +46,20 @@ fun KtTypeReference.createTypeBinding(trace: BindingContext): TypeBinding { +private fun createTypeBindingFromPsi( + trace: BindingContext, + psiElement: KtTypeElement, + type: KotlinType, + isArgumentFromQualifier: Boolean +): TypeBinding { val abbreviatedType = type.getAbbreviatedType() return if (abbreviatedType != null) - AbbreviatedTypeBinding(type, psiElement) + AbbreviatedTypeBinding(type, psiElement, isArgumentFromQualifier) else - ExplicitTypeBinding(trace, psiElement, type) + ExplicitTypeBinding(trace, psiElement, type, isArgumentFromQualifier) } fun KtCallableDeclaration.createTypeBindingForReturnType(trace: BindingContext): TypeBinding? { @@ -74,13 +81,20 @@ private class TypeArgumentBindingImpl( private class ExplicitTypeBinding( private val trace: BindingContext, override val psiElement: KtTypeElement, - override val type: KotlinType + override val type: KotlinType, + override val isArgumentFromQualifier: Boolean ) : TypeBinding { override val isInAbbreviation: Boolean get() = false override val arguments: List?> get() { - val psiTypeArguments = psiElement.typeArgumentsAsTypes + val psiTypeArguments = psiElement.typeArgumentsAsTypes.toMutableList() + val qualifierArgumentStartIndex = psiTypeArguments.size + var current = psiElement + while (current is KtUserType) { + current = current.qualifier ?: break + psiTypeArguments += current.typeArgumentsAsTypes + } assert(type.getAbbreviatedType() == null) { "Non-abbreviated type expected: $type" } val isErrorBinding = run { val sizeIsEqual = psiTypeArguments.size == type.arguments.size @@ -90,16 +104,17 @@ private class ExplicitTypeBinding( return psiTypeArguments.indices.map { index: Int -> // todo fix for List<*> - val jetTypeReference = psiTypeArguments[index] - val jetTypeElement = jetTypeReference?.typeElement ?: return@map null + val typeReference = psiTypeArguments[index] + val typeElement = typeReference?.typeElement ?: return@map null + val isArgumentFromQualifier = index >= qualifierArgumentStartIndex if (isErrorBinding) { - val nextJetType = trace[BindingContext.TYPE, jetTypeReference] ?: return@map null + val nextType = trace[BindingContext.TYPE, typeReference] ?: return@map null return@map TypeArgumentBindingImpl( - TypeProjectionImpl(nextJetType), + TypeProjectionImpl(nextType), null, - createTypeBindingFromPsi(trace, jetTypeElement, nextJetType) + createTypeBindingFromPsi(trace, typeElement, nextType, isArgumentFromQualifier) ) } @@ -107,7 +122,7 @@ private class ExplicitTypeBinding( return@map TypeArgumentBindingImpl( typeProjection, type.constructor.parameters[index], - createTypeBindingFromPsi(trace, jetTypeElement, typeProjection.type) + createTypeBindingFromPsi(trace, typeElement, typeProjection.type, isArgumentFromQualifier) ) } } @@ -115,13 +130,14 @@ private class ExplicitTypeBinding( private class AbbreviatedTypeBinding( override val type: KotlinType, - override val psiElement: KtTypeElement + override val psiElement: KtTypeElement, + override val isArgumentFromQualifier: Boolean ) : TypeBinding { override val isInAbbreviation: Boolean get() = true override val arguments: List?> get() = createTypeArgumentBindingsWithSinglePsiElement(type) { argumentType -> - AbbreviatedTypeBinding(argumentType, psiElement) + AbbreviatedTypeBinding(argumentType, psiElement, isArgumentFromQualifier) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt index af779ddb474..7724d42f86d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/VarianceChecker.kt @@ -18,6 +18,9 @@ package org.jetbrains.kotlin.resolve import com.intellij.psi.PsiElement import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.LanguageFeature.ReportTypeVarianceConflictOnQualifierArguments +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.PropertyAccessorDescriptorImpl @@ -43,7 +46,8 @@ class ManualVariance(val descriptor: TypeParameterDescriptor, val variance: Vari class VarianceChecker(trace: BindingTrace) { private val core = VarianceCheckerCore(trace.bindingContext, trace) - fun check(c: TopDownAnalysisContext) { + fun check(c: TopDownAnalysisContext, languageVersionSettings: LanguageVersionSettings) { + core.languageVersionSettings = languageVersionSettings core.check(c) } } @@ -59,6 +63,7 @@ class VarianceCheckerCore( private val diagnosticSink: DiagnosticSink, private val manualVariance: ManualVariance? = null ) { + internal var languageVersionSettings: LanguageVersionSettings? = null fun check(c: TopDownAnalysisContext) { checkClasses(c) @@ -153,7 +158,17 @@ class VarianceCheckerCore( ) { val varianceConflictDiagnosticData = VarianceConflictDiagnosticData(containingType, classifierDescriptor, position) val diagnostic = - if (isInAbbreviation) Errors.TYPE_VARIANCE_CONFLICT_IN_EXPANDED_TYPE else Errors.TYPE_VARIANCE_CONFLICT + when { + isArgumentFromQualifier -> { + if (languageVersionSettings?.supportsFeature(ReportTypeVarianceConflictOnQualifierArguments) == true) { + Errors.TYPE_VARIANCE_CONFLICT + } else { + Errors.TYPE_VARIANCE_CONFLICT_WARNING + } + } + isInAbbreviation -> Errors.TYPE_VARIANCE_CONFLICT_IN_EXPANDED_TYPE + else -> Errors.TYPE_VARIANCE_CONFLICT + } diagnosticSink.report(diagnostic.on(psiElement, varianceConflictDiagnosticData)) } return declarationVariance.allowsPosition(position) diff --git a/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.fir.kt b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.fir.kt new file mode 100644 index 00000000000..46d5ceaad76 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.fir.kt @@ -0,0 +1,23 @@ +// !LANGUAGE: -ReportTypeVarianceConflictOnQualifierArguments + +class Bar { + inner class Inner { + inner class SuperInner + } +} + +abstract class Foo { + abstract fun yuckyEventHandler( + fn: Bar<T>.Inner.() -> Unit + ): () -> Unit + + abstract fun second(fn: Bar<T>.Inner) + + abstract fun third(fn: Bar<T>.Inner.SuperInner) +} + +abstract class Baz { + abstract fun yuckyEventHandler( + fn: Bar<T>.Inner.() -> Unit + ): () -> Unit +} diff --git a/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt new file mode 100644 index 00000000000..e4db5f9d710 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt @@ -0,0 +1,23 @@ +// !LANGUAGE: -ReportTypeVarianceConflictOnQualifierArguments + +class Bar { + inner class Inner { + inner class SuperInner + } +} + +abstract class Foo { + abstract fun yuckyEventHandler( + fn: Bar<T>.Inner.() -> Unit + ): () -> Unit + + abstract fun second(fn: Bar<T>.Inner) + + abstract fun third(fn: Bar<T>.Inner.SuperInner) +} + +abstract class Baz { + abstract fun yuckyEventHandler( + fn: Bar<T>.Inner.() -> Unit + ): () -> Unit +} diff --git a/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.txt b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.txt new file mode 100644 index 00000000000..3b5bae81d63 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/typeVarianceConflict.txt @@ -0,0 +1,41 @@ +package + +public final class Bar { + public constructor Bar() + 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 inner class Inner /*captured type parameters: /*0*/ K*/ { + public constructor Inner() + 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 inner class SuperInner /*captured type parameters: /*0*/ K*/ { + public constructor SuperInner() + 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 abstract class Baz { + public constructor Baz() + 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 abstract fun yuckyEventHandler(/*0*/ fn: Bar.Inner.() -> kotlin.Unit): () -> kotlin.Unit +} + +public abstract class Foo { + public constructor Foo() + 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 abstract fun second(/*0*/ fn: Bar.Inner): kotlin.Unit + public abstract fun third(/*0*/ fn: Bar.Inner.SuperInner): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public abstract fun yuckyEventHandler(/*0*/ fn: Bar.Inner.() -> kotlin.Unit): () -> kotlin.Unit +} + diff --git a/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt b/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt new file mode 100644 index 00000000000..2b65d876a5a --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt @@ -0,0 +1,12 @@ +// FIR_IDENTICAL +// !LANGUAGE: +ReportTypeVarianceConflictOnQualifierArguments + +class Bar { + inner class Inner +} + +abstract class Foo { + abstract fun yuckyEventHandler( + fn: Bar<T>.Inner.() -> Unit + ): () -> Unit +} diff --git a/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.txt b/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.txt new file mode 100644 index 00000000000..44cbb1f0cb4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.txt @@ -0,0 +1,23 @@ +package + +public final class Bar { + public constructor Bar() + 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 inner class Inner /*captured type parameters: /*0*/ K*/ { + public constructor Inner() + 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 abstract class Foo { + public constructor Foo() + 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 abstract fun yuckyEventHandler(/*0*/ fn: Bar.Inner.() -> kotlin.Unit): () -> kotlin.Unit +} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index b463905f907..3b463e3864a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -17454,6 +17454,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); } + @Test + @TestMetadata("typeVarianceConflict.kt") + public void testTypeVarianceConflict() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflict.kt"); + } + + @Test + @TestMetadata("typeVarianceConflictFeatureOn.kt") + public void testTypeVarianceConflictFeatureOn() throws Exception { + runTest("compiler/testData/diagnostics/tests/inner/typeVarianceConflictFeatureOn.kt"); + } + @Test @TestMetadata("visibility.kt") public void testVisibility() throws Exception { diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 4b067106ca2..ed5bb6d5ffc 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -269,6 +269,7 @@ enum class LanguageFeature( ForbidExtensionFunctionTypeOnNonFunctionTypes(KOTLIN_1_9), // related to KT-43527 ProhibitEnumDeclaringClass(KOTLIN_1_9, kind = BUG_FIX), // KT-49653 StopPropagatingDeprecationThroughOverrides(KOTLIN_1_9, kind = BUG_FIX), // KT-47902 + ReportTypeVarianceConflictOnQualifierArguments(KOTLIN_1_9, kind = BUG_FIX), // KT-50947 // Disabled for indefinite time. See KT-48535 and related discussion ApproximateIntegerLiteralTypesInReceiverPosition(sinceVersion = null),