From 03304bce96f53d49c3ddfd94085ecd75654bd80a Mon Sep 17 00:00:00 2001 From: pyos Date: Thu, 12 Aug 2021 18:55:44 +0200 Subject: [PATCH] FIR: enhance Java type parameter bounds This also fixes handling of self-recursive types. TODO: fix jspecify/{strict,warn}Mode/Captured.fir.kt --- .../testData/builtIns/kotlin-collections.txt | 3 +- .../kotlin/fir/java/JavaSymbolProvider.kt | 73 +++---- .../kotlin/fir/java/JavaTypeConversion.kt | 17 +- .../kotlin/fir/java/JavaTypeParameterStack.kt | 4 +- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 18 +- .../java/enhancement/SignatureEnhancement.kt | 71 ++++-- .../utils/FirDeclarationBuildingUtils.kt | 14 +- .../testData/codegen/box/inference/kt47316.kt | 1 - .../jspecify/strictMode/Captured.fir.kt | 17 ++ .../jspecify/strictMode/Captured.kt | 1 - .../NonPlatformTypeParameter.fir.kt | 27 --- .../strictMode/NonPlatformTypeParameter.kt | 1 + .../NullnessUnspecifiedTypeParameter.fir.kt | 11 +- .../strictMode/TypeParameterBounds.fir.kt | 18 +- .../jspecify/strictMode/kt47422.fir.kt | 3 +- .../jspecify/strictMode/kt47437.fir.kt | 2 +- .../jspecify/warnMode/Captured.fir.kt | 17 ++ .../java8Tests/jspecify/warnMode/Captured.kt | 3 +- .../warnMode/NonPlatformTypeParameter.fir.kt | 6 +- .../NullnessUnspecifiedTypeParameter.fir.kt | 8 +- .../warnMode/TypeParameterBounds.fir.kt | 12 +- .../misc/classTypeParameterBound.fir.kt | 8 +- ...classTypeParameterBoundWithWarnings.fir.kt | 8 +- ...rameterAnnotationToEnhanceItsUsages.fir.kt | 2 +- .../tests/kt47920.fir.kt | 11 + .../foreignAnnotationsTests/tests/kt47920.kt | 1 - .../tests/inference/kt47316.fir.fail | 205 ------------------ .../java/checkEnhancedUpperBounds.fir.kt | 18 +- ...dUpperBoundsWithEnabledImprovements.fir.kt | 18 +- .../typeEnhancement/AbstractSignatureParts.kt | 6 +- 30 files changed, 222 insertions(+), 382 deletions(-) create mode 100644 compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.fir.kt delete mode 100644 compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt create mode 100644 compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.fir.kt create mode 100644 compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.fir.kt delete mode 100644 compiler/testData/diagnostics/tests/inference/kt47316.fir.fail diff --git a/compiler/fir/analysis-tests/testData/builtIns/kotlin-collections.txt b/compiler/fir/analysis-tests/testData/builtIns/kotlin-collections.txt index 672f3f2f4f0..b5c00a2a7f2 100644 --- a/compiler/fir/analysis-tests/testData/builtIns/kotlin-collections.txt +++ b/compiler/fir/analysis-tests/testData/builtIns/kotlin-collections.txt @@ -1,5 +1,5 @@ public/*package*/ open class ArraysUtilJVM : R|kotlin/Any| { - public/*package*/ open static fun |> asList(p0: T[]): java.util.List + public/*package*/ open static fun asList(p0: T[]): java.util.List public/*package*/ constructor(): R|kotlin/collections/ArraysUtilJVM| @@ -304,3 +304,4 @@ public abstract class ShortIterator : R|kotlin/collections/Iterator, packageFqName: FqName, name: Name) { } - private fun JavaTypeParameter.toFirTypeParameterSymbol( - javaTypeParameterStack: JavaTypeParameterStack - ): Pair { - val stored = javaTypeParameterStack.safeGet(this) - if (stored != null) return stored to true - val firSymbol = FirTypeParameterSymbol() - javaTypeParameterStack.addParameter(this, firSymbol) - return firSymbol to false - } - - private fun JavaTypeParameter.toFirTypeParameter( - firSymbol: FirTypeParameterSymbol, - javaTypeParameterStack: JavaTypeParameterStack - ): FirTypeParameter { - return FirTypeParameterBuilder().apply { + private fun JavaTypeParameter.toFirTypeParameter(javaTypeParameterStack: JavaTypeParameterStack): FirTypeParameter { + return buildTypeParameter { moduleData = this@JavaSymbolProvider.baseModuleData origin = FirDeclarationOrigin.Java resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES - this.name = this@toFirTypeParameter.name - symbol = firSymbol + name = this@toFirTypeParameter.name + symbol = FirTypeParameterSymbol() variance = INVARIANT isReified = false - addBounds(this@toFirTypeParameter, javaTypeParameterStack) - }.build() - } - - private fun FirTypeParameterBuilder.addBounds( - javaTypeParameter: JavaTypeParameter, - stack: JavaTypeParameterStack - ) { - for (upperBound in javaTypeParameter.upperBounds) { - bounds += upperBound.toFirResolvedTypeRef(session, stack, FirJavaTypeConversionMode.TYPE_PARAMETER_BOUND) - } - addDefaultBoundIfNecessary(isFlexible = true) - } - - private fun List.convertTypeParameters(stack: JavaTypeParameterStack): List { - return map { it.toFirTypeParameterSymbol(stack) }.mapIndexed { index, (symbol, initialized) -> - // This nasty logic is required, because type parameter bound can refer other type parameter from the list - // So we have to create symbols first, and type parameters themselves after them - if (initialized) symbol.fir - else this[index].toFirTypeParameter(symbol, stack) + javaTypeParameterStack.addParameter(this@toFirTypeParameter, symbol) + // TODO: should be lazy (in case annotations refer to the containing class) + annotations.addFromJava(session, this@toFirTypeParameter, javaTypeParameterStack) + for (upperBound in this@toFirTypeParameter.upperBounds) { + bounds += upperBound.toFirJavaTypeRef(session, javaTypeParameterStack) + } + if (bounds.isEmpty()) { + val builtinTypes = baseModuleData.session.builtinTypes + bounds += buildResolvedTypeRef { + type = ConeFlexibleType(builtinTypes.anyType.type, builtinTypes.nullableAnyType.type) + } + } } } + private fun List.convertTypeParameters(stack: JavaTypeParameterStack): List = + map { it.toFirTypeParameter(stack) } + override fun getClassLikeSymbolByFqName(classId: ClassId): FirRegularClassSymbol? { return try { if (!hasTopLevelClassOf(classId)) return null @@ -209,8 +192,15 @@ class JavaSymbolProvider( val firJavaClass = createFirJavaClass(javaClass, classSymbol, outerClassId, parentClassSymbol, classId, javaTypeParameterStack) parentClassTypeParameterStackCache.remove(classSymbol) parentClassEffectiveVisibilityCache.remove(classSymbol) + + // There's a bit of an ordering restriction here: + // 1. annotations should be added after the symbol is bound, as annotations can refer to the class itself; + // 2. bound/supertype conversion should happen here for the same reason; + // 3. type enhancement requires annotations to be already present (and supertypes can refer to type parameters). + firJavaClass.annotations.addFromJava(session, javaClass, javaTypeParameterStack) + val enhancement = FirSignatureEnhancement(firJavaClass, session) { emptyList() } + enhancement.enhanceTypeParameterBounds(firJavaClass.typeParameters) firJavaClass.convertSuperTypes(javaClass, javaTypeParameterStack) - firJavaClass.addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack) firJavaClass.replaceDeprecation(firJavaClass.getDeprecationInfos(session.languageVersionSettings.apiVersion)) return firJavaClass } @@ -397,7 +387,8 @@ class JavaSymbolProvider( returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack) resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES origin = FirDeclarationOrigin.Java - addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) + // TODO: check if this works properly with annotations that take the enum class as an argument + annotations.addFromJava(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) }.apply { containingClassForStaticMemberAttr = ConeClassLikeLookupTagImpl(classId) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeConversion.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeConversion.kt index e8001110391..68b900b953b 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeConversion.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeConversion.kt @@ -51,15 +51,21 @@ internal enum class FirJavaTypeConversionMode { DEFAULT, ANNOTATION_MEMBER, SUPERTYPE, TYPE_PARAMETER_BOUND } +internal fun FirTypeRef.resolveIfJavaType( + session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, + mode: FirJavaTypeConversionMode = FirJavaTypeConversionMode.DEFAULT +): FirTypeRef = when (this) { + is FirResolvedTypeRef -> this + is FirJavaTypeRef -> type.toFirResolvedTypeRef(session, javaTypeParameterStack, mode) + else -> this +} + internal fun FirTypeRef.toConeKotlinTypeProbablyFlexible( session: FirSession, javaTypeParameterStack: JavaTypeParameterStack, mode: FirJavaTypeConversionMode = FirJavaTypeConversionMode.DEFAULT ): ConeKotlinType = - when (this) { - is FirResolvedTypeRef -> this - is FirJavaTypeRef -> type.toFirResolvedTypeRef(session, javaTypeParameterStack, mode) - else -> null - }?.type ?: ConeKotlinErrorType(ConeSimpleDiagnostic("Type reference in Java not resolved: ${this::class.java}", DiagnosticKind.Java)) + (resolveIfJavaType(session, javaTypeParameterStack, mode) as? FirResolvedTypeRef)?.type + ?: ConeKotlinErrorType(ConeSimpleDiagnostic("Type reference in Java not resolved: ${this::class.java}", DiagnosticKind.Java)) internal fun JavaType.toFirJavaTypeRef(session: FirSession, javaTypeParameterStack: JavaTypeParameterStack): FirJavaTypeRef { return buildJavaTypeRef { @@ -199,6 +205,7 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound( classSymbol?.fir?.typeParameters?.eraseToUpperBounds(session, javaTypeParameterStack) ?: defaultArgs } } else { + // TODO: why is this condition needed? val useTypeParameters = mode != FirJavaTypeConversionMode.TYPE_PARAMETER_BOUND && mode != FirJavaTypeConversionMode.SUPERTYPE val typeParameters = runIf(useTypeParameters) { val classSymbol = session.symbolProvider.getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt index b7bff48d8af..452851ee7ea 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaTypeParameterStack.kt @@ -21,12 +21,10 @@ internal class JavaTypeParameterStack { } operator fun get(javaTypeParameter: JavaTypeParameter): FirTypeParameterSymbol { - return safeGet(javaTypeParameter) + return typeParameterMap[javaTypeParameter] ?: throw IllegalArgumentException("Cannot find Java type parameter $javaTypeParameter in stack") } - fun safeGet(javaTypeParameter: JavaTypeParameter) = typeParameterMap[javaTypeParameter] - companion object { val EMPTY: JavaTypeParameterStack = JavaTypeParameterStack() } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 1c42ac55122..21ceec402db 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -9,8 +9,6 @@ import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder -import org.jetbrains.kotlin.fir.builder.FirBuilderDsl import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirValueParameter @@ -18,7 +16,6 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* -import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference @@ -190,20 +187,7 @@ internal fun JavaAnnotation.toFirAnnotationCall( } } -@FirBuilderDsl -internal fun FirAnnotationContainerBuilder.addAnnotationsFrom( - session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack -) { - annotations.addAnnotationsFrom(session, javaAnnotationOwner, javaTypeParameterStack) -} - -internal fun FirJavaClass.addAnnotationsFrom( - session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack -) { - annotations.addAnnotationsFrom(session, javaAnnotationOwner, javaTypeParameterStack) -} - -internal fun MutableList.addAnnotationsFrom( +internal fun MutableList.addFromJava( session: FirSession, javaAnnotationOwner: JavaAnnotationOwner, javaTypeParameterStack: JavaTypeParameterStack diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index 40672a92dda..ea9ed6b81ba 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.java.FirJavaTypeConversionMode import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack import org.jetbrains.kotlin.fir.java.declarations.* +import org.jetbrains.kotlin.fir.java.resolveIfJavaType import org.jetbrains.kotlin.fir.java.toConeKotlinTypeProbablyFlexible import org.jetbrains.kotlin.fir.scopes.jvm.computeJvmDescriptor import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag @@ -178,6 +179,7 @@ class FirSignatureEnhancement( if (firMethod !is FirJavaMethod && firMethod !is FirJavaConstructor) { return original } + enhanceTypeParameterBounds(firMethod.typeParameters) return enhanceMethod(firMethod, original.callableId, name) } @@ -311,6 +313,44 @@ class FirSignatureEnhancement( return function.symbol } + fun enhanceTypeParameterBounds(typeParameters: List) { + // Type parameters can have interdependencies between them. Assuming that there are no top-level cycles + // (`A : B, B : A` - invalid), the cycles can still appear when type parameters use each other in argument + // position (`A : C, B : D` - valid). In this case the precise enhancement of each bound depends on + // the others' nullability, for which we need to enhance at least its head type constructor. + // + // While this is straightforward to do within a single class/method (enhance all bounds' head type + // constructors, then enhance fully), it's not so simple when two classes depend on each other (we need + // to enhance *both* classes' type parameters' bounds' heads first). This is why we replace each bound + // with an unenhanced version first: this ensures that the frontend at least doesn't fail. + // + // TODO: find a way to partially enhance type parameters of all classes before fully enhancing anything. + // TODO: should this be done in topological order on head type constructors? + // I.e. for `A : B, B : C` should we process `B` first? + typeParameters.replaceBounds { _, bound -> + bound.resolveIfJavaType(session, javaTypeParameterStack, FirJavaTypeConversionMode.TYPE_PARAMETER_BOUND) + } + typeParameters.replaceBounds { typeParameter, bound -> + enhanceTypeParameterBound(typeParameter, bound, forceOnlyHeadTypeConstructor = true) + } + typeParameters.replaceBounds { typeParameter, bound -> + enhanceTypeParameterBound(typeParameter, bound, forceOnlyHeadTypeConstructor = false) + } + } + + private inline fun List.replaceBounds(block: (FirTypeParameter, FirTypeRef) -> FirTypeRef) { + for (typeParameter in this) { + if (typeParameter is FirTypeParameter) { + typeParameter.replaceBounds(typeParameter.bounds.map { block(typeParameter, it) }) + } + } + } + + private fun enhanceTypeParameterBound(typeParameter: FirTypeParameter, bound: FirTypeRef, forceOnlyHeadTypeConstructor: Boolean) = + EnhancementSignatureParts( + session, typeQualifierResolver, typeParameter, isCovariant = false, forceOnlyHeadTypeConstructor, + AnnotationQualifierApplicabilityType.TYPE_PARAMETER_BOUNDS, context.defaultTypeQualifiers + ).enhance(bound, emptyList(), FirJavaTypeConversionMode.TYPE_PARAMETER_BOUND) // ================================================================================================ @@ -361,10 +401,9 @@ class FirSignatureEnhancement( predefinedEnhancementInfo: PredefinedFunctionEnhancementInfo? ): FirResolvedTypeRef { return owner.enhance( - typeQualifierResolver, overriddenMembers, - typeContainer = owner, isCovariant = true, - containerContext = memberContext, + typeContainer = owner, + isCovariant = true, containerContext = memberContext, containerApplicabilityType = if (owner is FirJavaField) AnnotationQualifierApplicabilityType.FIELD else AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE, @@ -408,10 +447,9 @@ class FirSignatureEnhancement( predefined: TypeEnhancementInfo?, forAnnotationMember: Boolean ): FirResolvedTypeRef = (this as FirCallableDeclaration).enhance( - typeQualifierResolver, overriddenMembers, - parameterContainer, false, - parameterContainer?.let { + parameterContainer, + false, parameterContainer?.let { methodContext.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, it.annotations) } ?: methodContext, AnnotationQualifierApplicabilityType.VALUE_PARAMETER, @@ -421,7 +459,6 @@ class FirSignatureEnhancement( ) private fun FirCallableDeclaration.enhance( - typeQualifierResolver: FirAnnotationTypeQualifierResolver, overriddenMembers: List, typeContainer: FirAnnotationContainer?, isCovariant: Boolean, @@ -431,15 +468,22 @@ class FirSignatureEnhancement( predefined: TypeEnhancementInfo?, forAnnotationMember: Boolean ): FirResolvedTypeRef { - val parts = EnhancementSignatureParts( - session, typeQualifierResolver, typeContainer, isCovariant, - containerApplicabilityType, containerContext.defaultTypeQualifiers - ) val typeRef = typeInSignature.getTypeRef(this) + val typeRefsFromOverridden = overriddenMembers.map { typeInSignature.getTypeRef(it) } val mode = if (forAnnotationMember) FirJavaTypeConversionMode.ANNOTATION_MEMBER else FirJavaTypeConversionMode.DEFAULT + return EnhancementSignatureParts( + session, typeQualifierResolver, typeContainer, isCovariant, forceOnlyHeadTypeConstructor = false, + containerApplicabilityType, containerContext.defaultTypeQualifiers + ).enhance(typeRef, typeRefsFromOverridden, mode, predefined) + } + + private fun EnhancementSignatureParts.enhance( + typeRef: FirTypeRef, typeRefsFromOverridden: List, + mode: FirJavaTypeConversionMode, predefined: TypeEnhancementInfo? = null + ): FirResolvedTypeRef { val typeWithoutEnhancement = typeRef.toConeKotlinType(mode) - val typesFromOverridden = overriddenMembers.map { typeInSignature.getTypeRef(it).toConeKotlinType(mode) } - val qualifiers = with(parts) { typeWithoutEnhancement.computeIndexedQualifiers(typesFromOverridden, predefined) } + val typesFromOverridden = typeRefsFromOverridden.map { it.toConeKotlinType(mode) } + val qualifiers = typeWithoutEnhancement.computeIndexedQualifiers(typesFromOverridden, predefined) return buildResolvedTypeRef { type = typeWithoutEnhancement.enhance(session, qualifiers) ?: typeWithoutEnhancement annotations += typeRef.annotations @@ -455,6 +499,7 @@ private class EnhancementSignatureParts( override val annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver, private val typeContainer: FirAnnotationContainer?, override val isCovariant: Boolean, + override val forceOnlyHeadTypeConstructor: Boolean, override val containerApplicabilityType: AnnotationQualifierApplicabilityType, override val containerDefaultTypeQualifiers: JavaTypeQualifiersByElementType? ) : AbstractSignatureParts() { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationBuildingUtils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationBuildingUtils.kt index 3de6858ea9a..32b469d2efe 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationBuildingUtils.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirDeclarationBuildingUtils.kt @@ -12,20 +12,10 @@ import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl import org.jetbrains.kotlin.fir.declarations.impl.FirRegularClassImpl -import org.jetbrains.kotlin.fir.types.ConeFlexibleType -import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef -fun FirTypeParameterBuilder.addDefaultBoundIfNecessary(isFlexible: Boolean = false) { +fun FirTypeParameterBuilder.addDefaultBoundIfNecessary() { if (bounds.isEmpty()) { - val builtinTypes = moduleData.session.builtinTypes - val type = if (isFlexible) { - buildResolvedTypeRef { - type = ConeFlexibleType(builtinTypes.anyType.type, builtinTypes.nullableAnyType.type) - } - } else { - builtinTypes.nullableAnyType - } - bounds += type + bounds += moduleData.session.builtinTypes.nullableAnyType } } diff --git a/compiler/testData/codegen/box/inference/kt47316.kt b/compiler/testData/codegen/box/inference/kt47316.kt index 0c93ef24ce5..c5d8735bcac 100644 --- a/compiler/testData/codegen/box/inference/kt47316.kt +++ b/compiler/testData/codegen/box/inference/kt47316.kt @@ -1,6 +1,5 @@ // !LANGUAGE: -ProperTypeInferenceConstraintsProcessing // TARGET_BACKEND: JVM -// IGNORE_BACKEND_FIR: JVM_IR // FILE: GoBuildingRunningState.java public abstract class GoBuildingRunningState>> implements RunProfileState { diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.fir.kt new file mode 100644 index 00000000000..aa6e98bed6c --- /dev/null +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.fir.kt @@ -0,0 +1,17 @@ +// JSPECIFY_STATE: strict +// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +// FILE: J1.java +import org.jetbrains.annotations.Nullable; + +public interface J1 { + @Nullable + public static T foo(J1 x) { return null; } +} + +// FILE: J2.java +import org.jspecify.nullness.Nullable; + +public interface J2 extends J1 { } + +// FILE: kotlin.kt +private fun J2<*>.bar() = J1.foo(this) diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.kt index f0aa0bebf42..cc6a973addf 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Captured.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // JSPECIFY_STATE: strict // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode // FILE: J1.java diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt deleted file mode 100644 index 1ded9006c78..00000000000 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt +++ /dev/null @@ -1,27 +0,0 @@ -// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +TypeEnhancementImprovementsInStrictMode -// JSPECIFY_STATE: strict -// MUTE_FOR_PSI_CLASS_FILES_READING - -// FILE: NonPlatformTypeParameter.java -import org.jspecify.nullness.*; - -public class NonPlatformTypeParameter { - public void foo(T t) {} - public void bar(E e) {} -} - -// FILE: Test.java -public class Test {} - -// FILE: main.kt -fun main(a1: NonPlatformTypeParameter, a2: NonPlatformTypeParameter, x: T): Unit { - a1.foo(null) - a1.bar(null) - a1.bar(null) - a1.bar(x) - - a2.foo(null) - a2.bar(null) - a2.bar(null) - a2.bar(x) -} diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt index 08bbc182db2..f79a6a4f077 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +TypeEnhancementImprovementsInStrictMode // JSPECIFY_STATE: strict // MUTE_FOR_PSI_CLASS_FILES_READING diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt index 512fea6e973..125c8aeea6d 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt @@ -14,16 +14,19 @@ public class NullnessUnspecifiedTypeParameter { public class Test {} // FILE: main.kt -fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter, x: Test): Unit { - a1.foo(null) +// jspecify_nullness_mismatch +fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit { + // jspecify_nullness_mismatch + a1.foo(null) a1.foo(1) a2.foo(null) a2.foo(1) + // jspecify_nullness_mismatch, jspecify_nullness_mismatch + a1.bar(null, null) // jspecify_nullness_mismatch - a1.bar(null, null) - a1.bar(x, null) + a1.bar(x, null) a1.bar(x, 1) // jspecify_nullness_mismatch diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt index c203846bb4d..468edc2c8cc 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt @@ -21,20 +21,26 @@ public class B { public class Test {} // FILE: main.kt -fun main(a1: A, a2: A, b1: B, b2: B, x: T): Unit { +// jspecify_nullness_mismatch, jspecify_nullness_mismatch +fun main(a1: A<Any?>, a2: A, b1: B<Any?>, b2: B, x: T): Unit { a1.foo(null) - a1.bar(null) + // jspecify_nullness_mismatch, jspecify_nullness_mismatch + a1.bar<T?>(null) a1.bar(x) a2.foo(null) - a2.bar(null) + // jspecify_nullness_mismatch, jspecify_nullness_mismatch + a2.bar<T?>(null) a2.bar(x) b1.foo(null) - b1.bar(null) + // jspecify_nullness_mismatch, jspecify_nullness_mismatch + b1.bar<T?>(null) b1.bar(x) - b2.foo(null) - b2.bar(null) + // jspecify_nullness_mismatch + b2.foo(null) + // jspecify_nullness_mismatch, jspecify_nullness_mismatch + b2.bar<T?>(null) b2.bar(x) } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47422.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47422.fir.kt index ff90cc8b4d9..8629d6caf57 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47422.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47422.fir.kt @@ -99,7 +99,8 @@ fun test3() { // String in Foo is not null isNotNullAndNullableStringInFoo( UtilNullMarkedGeneric.getFooOfK(), - UtilNullMarkedGeneric.getFooOfK() + // jspecify_nullness_mismatch + UtilNullMarkedGeneric.getFooOfK() ) } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47437.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47437.fir.kt index 9a9231a4cdb..f17605c72dc 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47437.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/kt47437.fir.kt @@ -14,5 +14,5 @@ public class Foo { // FILE: main.kt fun test(): Foo { - return ")!>Foo.create() + return ")!>Foo.create() } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.fir.kt new file mode 100644 index 00000000000..ccaffbd21df --- /dev/null +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.fir.kt @@ -0,0 +1,17 @@ +// JSPECIFY_STATE: warn +// !LANGUAGE: +TypeEnhancementImprovementsInStrictMode +// FILE: J1.java +import org.jetbrains.annotations.Nullable; + +public interface J1 { + @Nullable + public static T foo(J1 x) { return null; } +} + +// FILE: J2.java +import org.jspecify.nullness.Nullable; + +public interface J2 extends J1 { } + +// FILE: kotlin.kt +private fun J2<*>.bar() = J1.foo(this) diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.kt index df2c1439af4..a6d3d7413b2 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Captured.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // JSPECIFY_STATE: warn // !LANGUAGE: +TypeEnhancementImprovementsInStrictMode // FILE: J1.java @@ -15,4 +14,4 @@ import org.jspecify.nullness.Nullable; public interface J2 extends J1 { } // FILE: kotlin.kt -private fun J2<*>.bar() = J1.foo(this) \ No newline at end of file +private fun J2<*>.bar() = J1.foo(this) diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.kt index c07db7b6b46..0fb57a464ec 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.kt @@ -17,11 +17,11 @@ public class Test {} fun main(a1: NonPlatformTypeParameter, a2: NonPlatformTypeParameter, x: T): Unit { a1.foo(null) a1.bar(null) - a1.bar(null) + a1.bar(null) a1.bar(x) - a2.foo(null) + a2.foo(null) a2.bar(null) - a2.bar(null) + a2.bar(null) a2.bar(x) } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.kt index 2dc7fa58708..0d140526495 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.kt @@ -13,15 +13,15 @@ public class NullnessUnspecifiedTypeParameter { public class Test {} // FILE: main.kt -fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter, x: Test): Unit { - a1.foo(null) +fun main(a1: NullnessUnspecifiedTypeParameter, a2: NullnessUnspecifiedTypeParameter<Any?>, x: Test): Unit { + a1.foo(null) a1.foo(1) a2.foo(null) a2.foo(1) - a1.bar(null, null) - a1.bar(x, null) + a1.bar(null, null) + a1.bar(x, null) a1.bar(x, 1) a2.bar(null, null) diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.kt index d03604d890b..d94132a205c 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.kt @@ -20,20 +20,20 @@ public class B { public class Test {} // FILE: main.kt -fun main(a1: A, a2: A, b1: B, b2: B, x: T): Unit { +fun main(a1: A<Any?>, a2: A, b1: B<Any?>, b2: B, x: T): Unit { a1.foo(null) - a1.bar(null) + a1.bar<T?>(null) a1.bar(x) a2.foo(null) - a2.bar(null) + a2.bar<T?>(null) a2.bar(x) b1.foo(null) - b1.bar(null) + b1.bar<T?>(null) b1.bar(x) - b2.foo(null) - b2.bar(null) + b2.foo(null) + b2.bar<T?>(null) b2.bar(x) } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBound.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBound.fir.kt index a0cf8342d86..c1a4593761c 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBound.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBound.fir.kt @@ -13,13 +13,13 @@ public class ClassTypeParameterBound { } // FILE: main.kt -fun main(x: ClassTypeParameterBound, y: ClassTypeParameterBound, a: String?, b: String) { - val x2 = ClassTypeParameterBound() +fun main(x: ClassTypeParameterBound<String?>, y: ClassTypeParameterBound, a: String?, b: String) { + val x2 = ClassTypeParameterBound<String?>() val y2 = ClassTypeParameterBound() - val x3 = ClassTypeParameterBound(a) + val x3 = ClassTypeParameterBound(a) val y3 = ClassTypeParameterBound(b) - val x4: ClassTypeParameterBound = ClassTypeParameterBound() + val x4: ClassTypeParameterBound<String?> = ClassTypeParameterBound() val y4: ClassTypeParameterBound = ClassTypeParameterBound() } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBoundWithWarnings.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBoundWithWarnings.fir.kt index b869447f4a9..0c215ac6846 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBoundWithWarnings.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/classTypeParameterBoundWithWarnings.fir.kt @@ -13,13 +13,13 @@ public class ClassTypeParameterBoundWithWarnings { } // FILE: main.kt -fun main(x: ClassTypeParameterBoundWithWarnings, y: ClassTypeParameterBoundWithWarnings, a: String?, b: String) { - val x2 = ClassTypeParameterBoundWithWarnings() +fun main(x: ClassTypeParameterBoundWithWarnings<String?>, y: ClassTypeParameterBoundWithWarnings, a: String?, b: String) { + val x2 = ClassTypeParameterBoundWithWarnings<String?>() val y2 = ClassTypeParameterBoundWithWarnings() - val x3 = ClassTypeParameterBoundWithWarnings(a) + val x3 = ClassTypeParameterBoundWithWarnings(a) val y3 = ClassTypeParameterBoundWithWarnings(b) - val x4: ClassTypeParameterBoundWithWarnings = ClassTypeParameterBoundWithWarnings() + val x4: ClassTypeParameterBoundWithWarnings<String?> = ClassTypeParameterBoundWithWarnings() val y4: ClassTypeParameterBoundWithWarnings = ClassTypeParameterBoundWithWarnings() } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/useTypeParameterAnnotationToEnhanceItsUsages.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/useTypeParameterAnnotationToEnhanceItsUsages.fir.kt index e9c7c5350c4..eb89678a509 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/useTypeParameterAnnotationToEnhanceItsUsages.fir.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/misc/useTypeParameterAnnotationToEnhanceItsUsages.fir.kt @@ -10,5 +10,5 @@ public interface MapLike<@org.jetbrains.annotations.NotNull K> { // FILE: main.kt fun test2(map : MapLike, x2: Int?) { - map.put(x2) + map.put(x2) } diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.fir.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.fir.kt new file mode 100644 index 00000000000..dddebe62d5a --- /dev/null +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.fir.kt @@ -0,0 +1,11 @@ +// MUTE_FOR_PSI_CLASS_FILES_READING + +// FILE: J1.java +import io.reactivex.rxjava3.annotations.*; + +public class J1<@NonNull T> {} + +// FILE: main.kt +fun main() { + J1<Any?>() // violated nullability, no warnings; but there is an error with -Xtype-enhancement-improvements-strict-mode +} diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.kt index 4329a426411..baaede4d2a9 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/tests/kt47920.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // MUTE_FOR_PSI_CLASS_FILES_READING // FILE: J1.java diff --git a/compiler/testData/diagnostics/tests/inference/kt47316.fir.fail b/compiler/testData/diagnostics/tests/inference/kt47316.fir.fail deleted file mode 100644 index 1761a44792b..00000000000 --- a/compiler/testData/diagnostics/tests/inference/kt47316.fir.fail +++ /dev/null @@ -1,205 +0,0 @@ -Fir is not initialized for FirRegularClassSymbol GoBuildingRunConfiguration -java.lang.IllegalStateException: Fir is not initialized for FirRegularClassSymbol GoBuildingRunConfiguration - at org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol.getFir(AbstractFirBasedSymbol.kt:16) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound(JavaUtils.kt:408) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound$default(JavaUtils.kt:363) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement(JavaUtils.kt:243) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement$default(JavaUtils.kt:235) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement(JavaUtils.kt:146) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement$default(JavaUtils.kt:137) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeProjectionWithoutEnhancement(JavaUtils.kt:613) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound(JavaUtils.kt:413) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound$default(JavaUtils.kt:363) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement(JavaUtils.kt:243) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement$default(JavaUtils.kt:235) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toFirResolvedTypeRef(JavaUtils.kt:129) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.addBounds(JavaSymbolProvider.kt:121) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.toFirTypeParameter(JavaSymbolProvider.kt:112) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.convertTypeParameters(JavaSymbolProvider.kt:136) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.createFirJavaClass(JavaSymbolProvider.kt:253) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.convertJavaClassToFir(JavaSymbolProvider.kt:202) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.access$convertJavaClassToFir(JavaSymbolProvider.kt:46) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider$classCache$2.invoke(JavaSymbolProvider.kt:61) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider$classCache$2.invoke(JavaSymbolProvider.kt:59) - at org.jetbrains.kotlin.fir.caches.FirThreadUnsafeCacheWithPostCompute.getValue(FirThreadUnsafeCachesFactory.kt:47) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getFirJavaClass(JavaSymbolProvider.kt:150) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getFirJavaClass$default(JavaSymbolProvider.kt:148) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getClassLikeSymbolByFqName(JavaSymbolProvider.kt:142) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getClassLikeSymbolByFqName(JavaSymbolProvider.kt:46) - at org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider.getClassLikeSymbolByFqName(FirCompositeSymbolProvider.kt:51) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound(JavaUtils.kt:393) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeForFlexibleBound$default(JavaUtils.kt:363) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement(JavaUtils.kt:243) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toConeKotlinTypeWithoutEnhancement$default(JavaUtils.kt:235) - at org.jetbrains.kotlin.fir.java.JavaUtilsKt.toFirResolvedTypeRef(JavaUtils.kt:129) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.addBounds(JavaSymbolProvider.kt:121) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.toFirTypeParameter(JavaSymbolProvider.kt:112) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.convertTypeParameters(JavaSymbolProvider.kt:136) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.createFirJavaClass(JavaSymbolProvider.kt:253) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.convertJavaClassToFir(JavaSymbolProvider.kt:202) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.access$convertJavaClassToFir(JavaSymbolProvider.kt:46) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider$classCache$2.invoke(JavaSymbolProvider.kt:61) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider$classCache$2.invoke(JavaSymbolProvider.kt:59) - at org.jetbrains.kotlin.fir.caches.FirThreadUnsafeCacheWithPostCompute.getValue(FirThreadUnsafeCachesFactory.kt:47) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getFirJavaClass(JavaSymbolProvider.kt:150) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getFirJavaClass$default(JavaSymbolProvider.kt:148) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getClassLikeSymbolByFqName(JavaSymbolProvider.kt:142) - at org.jetbrains.kotlin.fir.java.JavaSymbolProvider.getClassLikeSymbolByFqName(JavaSymbolProvider.kt:46) - at org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider.getClassLikeSymbolByFqName(FirCompositeSymbolProvider.kt:51) - at org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope.processClassifiersByNameWithSubstitution(FirPackageMemberScope.kt:36) - at org.jetbrains.kotlin.fir.scopes.FirCompositeScope.processClassifiersByNameWithSubstitution(FirCompositeScope.kt:21) - at org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl.resolveToSymbol(FirTypeResolverImpl.kt:63) - at org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl.resolveType(FirTypeResolverImpl.kt:180) - at org.jetbrains.kotlin.fir.resolve.transformers.FirSpecificTypeResolverTransformer.transformTypeRef(FirSpecificTypeResolverTransformer.kt:59) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformTypeRef(FirBodyResolveTransformer.kt:68) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformTypeRef(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer.transformTypeRefWithNullability(FirDefaultTransformer.kt:28) - at org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer.transformUserTypeRef(FirDefaultTransformer.kt:40) - at org.jetbrains.kotlin.fir.types.FirUserTypeRef.transform(FirUserTypeRef.kt:29) - at org.jetbrains.kotlin.fir.expressions.impl.FirTypeOperatorCallImpl.transformConversionTypeRef(FirTypeOperatorCallImpl.kt:50) - at org.jetbrains.kotlin.fir.expressions.impl.FirTypeOperatorCallImpl.transformConversionTypeRef(FirTypeOperatorCallImpl.kt:22) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer.transformTypeOperatorCall(FirExpressionsResolveTransformer.kt:578) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformTypeOperatorCall(FirBodyResolveTransformer.kt:143) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformTypeOperatorCall(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall.transform(FirTypeOperatorCall.kt:30) - at org.jetbrains.kotlin.fir.expressions.impl.FirWhenBranchImpl.transformCondition(FirWhenBranchImpl.kt:37) - at org.jetbrains.kotlin.fir.expressions.impl.FirWhenBranchImpl.transformCondition(FirWhenBranchImpl.kt:19) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirControlFlowStatementsResolveTransformer.transformWhenBranch(FirControlFlowStatementsResolveTransformer.kt:113) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformWhenBranch(FirBodyResolveTransformer.kt:332) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformWhenBranch(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.expressions.FirWhenBranch.transform(FirWhenBranch.kt:27) - at org.jetbrains.kotlin.fir.visitors.FirTransformerUtilKt.transformInplace(FirTransformerUtil.kt:19) - at org.jetbrains.kotlin.fir.expressions.impl.FirWhenExpressionImpl.transformBranches(FirWhenExpressionImpl.kt:77) - at org.jetbrains.kotlin.fir.expressions.impl.FirWhenExpressionImpl.transformBranches(FirWhenExpressionImpl.kt:24) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirControlFlowStatementsResolveTransformer$transformWhenExpression$2.invoke(FirControlFlowStatementsResolveTransformer.kt:70) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirControlFlowStatementsResolveTransformer$transformWhenExpression$2.invoke(FirControlFlowStatementsResolveTransformer.kt:63) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext.withWhenExpression(BodyResolveContext.kt:714) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirControlFlowStatementsResolveTransformer.transformWhenExpression(FirControlFlowStatementsResolveTransformer.kt:63) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformWhenExpression(FirBodyResolveTransformer.kt:328) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformWhenExpression(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.expressions.FirWhenExpression.transform(FirWhenExpression.kt:35) - at org.jetbrains.kotlin.fir.expressions.FirExpressionUtilKt.transformStatementsIndexed(FirExpressionUtil.kt:140) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer.transformBlockInCurrentScope$resolve(FirExpressionsResolveTransformer.kt:323) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirExpressionsResolveTransformer.transformBlock(FirExpressionsResolveTransformer.kt:314) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformBlock(FirBodyResolveTransformer.kt:122) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformBlock(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.expressions.FirBlock.transform(FirBlock.kt:28) - at org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl.transformBody(FirSimpleFunctionImpl.kt:99) - at org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl.transformChildren(FirSimpleFunctionImpl.kt:75) - at org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl.transformChildren(FirSimpleFunctionImpl.kt:33) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformElement(FirBodyResolveTransformer.kt:60) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformDeclarationContent(FirBodyResolveTransformer.kt:244) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer.transformDeclarationContent(FirDeclarationsResolveTransformer.kt:69) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer.transformFunction(FirDeclarationsResolveTransformer.kt:527) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer.transformFunctionWithGivenSignature(FirDeclarationsResolveTransformer.kt:490) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer.access$transformFunctionWithGivenSignature(FirDeclarationsResolveTransformer.kt:41) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer$transformSimpleFunction$1$1.invoke(FirDeclarationsResolveTransformer.kt:479) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer$transformSimpleFunction$1$1.invoke(FirDeclarationsResolveTransformer.kt:477) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext.forFunctionBody(BodyResolveContext.kt:896) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer.transformSimpleFunction(FirDeclarationsResolveTransformer.kt:477) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformSimpleFunction(FirBodyResolveTransformer.kt:281) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformSimpleFunction(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.declarations.FirSimpleFunction.transform(FirSimpleFunction.kt:52) - at org.jetbrains.kotlin.fir.visitors.FirTransformerUtilKt.transformInplace(FirTransformerUtil.kt:19) - at org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl.transformDeclarations(FirFileImpl.kt:61) - at org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl.transformChildren(FirFileImpl.kt:46) - at org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl.transformChildren(FirFileImpl.kt:25) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformElement(FirBodyResolveTransformer.kt:60) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformDeclarationContent(FirBodyResolveTransformer.kt:244) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformFile(FirBodyResolveTransformer.kt:54) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer.transformFile(FirBodyResolveTransformer.kt:27) - at org.jetbrains.kotlin.fir.declarations.FirFile.transform(FirFile.kt:37) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformerAdapter.transformFile(FirBodyResolveTransformerAdapters.kt:37) - at org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformerAdapter.transformFile(FirBodyResolveTransformerAdapters.kt:23) - at org.jetbrains.kotlin.fir.declarations.FirFile.transform(FirFile.kt:37) - at org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor.processFile(FirResolveProcessor.kt:29) - at org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor.process(FirTotalResolveProcessor.kt:23) - at org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade.runResolution(FirAnalyzerFacade.kt:69) - at org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade.analyze(FirFrontendFacade.kt:75) - at org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade.analyze(FirFrontendFacade.kt:26) - at org.jetbrains.kotlin.test.model.FrontendFacade.transform(Facades.kt:36) - at org.jetbrains.kotlin.test.model.FrontendFacade.transform(Facades.kt:25) - at org.jetbrains.kotlin.test.TestRunner.processModule(TestRunner.kt:125) - at org.jetbrains.kotlin.test.TestRunner.runTestImpl(TestRunner.kt:66) - at org.jetbrains.kotlin.test.TestRunner.runTest(TestRunner.kt:20) - at org.jetbrains.kotlin.test.TestRunner.runTest$default(TestRunner.kt:18) - at org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest.runTest(AbstractKotlinCompilerTest.kt:80) - at org.jetbrains.kotlin.test.runners.FirOldFrontendDiagnosticsTestGenerated$Tests$Inference.testKt47316(FirOldFrontendDiagnosticsTestGenerated.java:12407) - at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) - at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) - at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) - at java.lang.reflect.Method.invoke(Method.java:498) - at org.junit.platform.commons.util.ReflectionUtils.invokeMethod(ReflectionUtils.java:688) - at org.junit.jupiter.engine.execution.MethodInvocation.proceed(MethodInvocation.java:60) - at org.junit.jupiter.engine.execution.InvocationInterceptorChain$ValidatingInvocation.proceed(InvocationInterceptorChain.java:131) - at org.junit.jupiter.engine.extension.TimeoutExtension.intercept(TimeoutExtension.java:149) - at org.junit.jupiter.engine.extension.TimeoutExtension.interceptTestableMethod(TimeoutExtension.java:140) - at org.junit.jupiter.engine.extension.TimeoutExtension.interceptTestMethod(TimeoutExtension.java:84) - at org.junit.jupiter.engine.execution.ExecutableInvoker$ReflectiveInterceptorCall.lambda$ofVoidMethod$0(ExecutableInvoker.java:115) - at org.junit.jupiter.engine.execution.ExecutableInvoker.lambda$invoke$0(ExecutableInvoker.java:105) - at org.junit.jupiter.engine.execution.InvocationInterceptorChain$InterceptedInvocation.proceed(InvocationInterceptorChain.java:106) - at org.junit.jupiter.engine.execution.InvocationInterceptorChain.proceed(InvocationInterceptorChain.java:64) - at org.junit.jupiter.engine.execution.InvocationInterceptorChain.chainAndInvoke(InvocationInterceptorChain.java:45) - at org.junit.jupiter.engine.execution.InvocationInterceptorChain.invoke(InvocationInterceptorChain.java:37) - at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java:104) - at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java:98) - at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.lambda$invokeTestMethod$6(TestMethodTestDescriptor.java:210) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.invokeTestMethod(TestMethodTestDescriptor.java:206) - at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.execute(TestMethodTestDescriptor.java:131) - at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.execute(TestMethodTestDescriptor.java:65) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:139) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:129) - at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:127) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:126) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:84) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService$ExclusiveTask.compute(ForkJoinPoolHierarchicalTestExecutorService.java:185) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService.invokeAll(ForkJoinPoolHierarchicalTestExecutorService.java:129) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:143) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:129) - at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:127) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:126) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:84) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService$ExclusiveTask.compute(ForkJoinPoolHierarchicalTestExecutorService.java:185) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService.invokeAll(ForkJoinPoolHierarchicalTestExecutorService.java:129) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:143) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:129) - at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:127) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:126) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:84) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService$ExclusiveTask.compute(ForkJoinPoolHierarchicalTestExecutorService.java:185) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService.invokeAll(ForkJoinPoolHierarchicalTestExecutorService.java:129) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:143) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:129) - at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:127) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:126) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:84) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService$ExclusiveTask.compute(ForkJoinPoolHierarchicalTestExecutorService.java:185) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService.invokeAll(ForkJoinPoolHierarchicalTestExecutorService.java:129) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$5(NodeTestTask.java:143) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$7(NodeTestTask.java:129) - at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:127) - at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:126) - at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:84) - at org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService$ExclusiveTask.compute(ForkJoinPoolHierarchicalTestExecutorService.java:185) - at java.util.concurrent.RecursiveAction.exec(RecursiveAction.java:189) - at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289) - at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1056) - at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1692) - at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:157) - diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBounds.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBounds.fir.kt index 48b92c78f22..42d2ba2730c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBounds.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBounds.fir.kt @@ -15,11 +15,11 @@ import java.util.Collection; public class ListLike> {} // FILE: main.kt -fun test0(map : MapLike) {} -fun test11(map : MapLike) {} -fun test12(map : MapLike) {} +fun test0(map : MapLike<Int?, Int>) {} +fun test11(map : MapLike<K, K>) {} +fun test12(map : MapLike<K?, K>) {} fun test13(map : MapLike) {} -fun test14(map : MapLike) {} +fun test14(map : MapLike<K?, K>) {} class Foo @@ -27,11 +27,11 @@ typealias A = MapLike typealias A2 = Foo> typealias A3 = ListLike> -fun main1(x: A) {} +fun main1(x: A) {} fun main2(x: A2) {} -fun main3(x: A3) {} +fun main3(x: A3) {} fun main3() { - val x = A3() // TODO: support reporting errors on typealias constructor calls - val x2 = A() // TODO: support reporting errors on typealias constructor calls - val y: A3 = A3() + val x = A3<Int?>() // TODO: support reporting errors on typealias constructor calls + val x2 = A<Int?>() // TODO: support reporting errors on typealias constructor calls + val y: A3 = A3<Int?>() } diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBoundsWithEnabledImprovements.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBoundsWithEnabledImprovements.fir.kt index 4d21e488c5e..ba79ff60f9d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBoundsWithEnabledImprovements.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/checkEnhancedUpperBoundsWithEnabledImprovements.fir.kt @@ -15,11 +15,11 @@ import java.util.Collection; public class ListLike> {} // FILE: main.kt -fun test0(map : MapLike) {} -fun test11(map : MapLike) {} -fun test12(map : MapLike) {} +fun test0(map : MapLike<Int?, Int>) {} +fun test11(map : MapLike<K, K>) {} +fun test12(map : MapLike<K?, K>) {} fun test13(map : MapLike) {} -fun test14(map : MapLike) {} +fun test14(map : MapLike<K?, K>) {} class Foo @@ -27,11 +27,11 @@ typealias A = MapLike typealias A2 = Foo> typealias A3 = ListLike> -fun main1(x: A) {} +fun main1(x: A) {} fun main2(x: A2) {} -fun main3(x: A3) {} +fun main3(x: A3) {} fun main3() { - val x = A3() // TODO: support reporting errors on typealias constructor calls - val x2 = A() - val y: A3 = A3() + val x = A3<Int?>() // TODO: support reporting errors on typealias constructor calls + val x2 = A<Int?>() + val y: A3 = A3<Int?>() } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt index 6558f27e44c..74354c35e85 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt @@ -27,6 +27,9 @@ abstract class AbstractSignatureParts { abstract val skipRawTypeArguments: Boolean abstract val typeSystem: TypeSystemContext + open val forceOnlyHeadTypeConstructor: Boolean + get() = false + abstract val Annotation.forceWarning: Boolean abstract val KotlinTypeMarker.annotations: Iterable @@ -179,7 +182,8 @@ abstract class AbstractSignatureParts { // (outermost type), unless the type in the subclass is interchangeable with the all the types in superclasses: // e.g. we have (Mutable)List! in the subclass and { List, (Mutable)List! } from superclasses // Note that `this` is flexible here, so it's equal to it's bounds - val onlyHeadTypeConstructor = isCovariant && overrides.any { !this@computeIndexedQualifiers.isEqual(it) } + val onlyHeadTypeConstructor = forceOnlyHeadTypeConstructor || + (isCovariant && overrides.any { !this@computeIndexedQualifiers.isEqual(it) }) val treeSize = if (onlyHeadTypeConstructor) 1 else indexedThisType.size val computedResult = Array(treeSize) { index ->