From 7306256127b2ca57a29aa295f71f31d5a7b1bbe1 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 2 Jun 2021 20:02:07 +0200 Subject: [PATCH] JVM IR: support mutability-flexible types --- .../backend/jvm/JvmGeneratorExtensionsImpl.kt | 8 +- .../kotlin/backend/jvm/JvmSymbols.kt | 3 + .../backend/jvm/codegen/AnnotationCodegen.kt | 1 + .../kotlin/ir/descriptors/IrBuiltIns.kt | 7 ++ .../kotlin/ir/types/IrTypeSystemContext.kt | 13 +-- .../ir/types/jvmSpecificFlexibleTypes.kt | 85 ++++++++++++++----- .../kotlin/ir/util/StubGeneratorExtensions.kt | 3 + .../kotlin/ir/util/TypeTranslator.kt | 10 +++ .../reflection/typeOf/flexibleTypes_after.kt | 1 - .../ir/irText/firProblems/AllCandidates.txt | 2 +- .../firProblems/SyntheticSetterType.txt | 2 +- .../typeParametersInImplicitCast.kt.txt | 2 +- .../typeParametersInImplicitCast.txt | 8 +- .../testData/ir/irText/stubs/builtinMap.txt | 2 +- .../ir/irText/types/javaWildcardType.kt.txt | 8 +- .../ir/irText/types/javaWildcardType.txt | 36 ++++---- ...edNullabilityInDestructuringAssignment.txt | 2 +- .../enhancedNullabilityInForLoop.txt | 8 +- .../ir/irText/types/rawTypeInSignature.kt.txt | 4 +- .../ir/irText/types/rawTypeInSignature.txt | 18 ++-- .../jetbrains/kotlin/types/flexibleTypes.kt | 13 ++- 21 files changed, 149 insertions(+), 87 deletions(-) diff --git a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt index ebb19665b9f..6d114fe943d 100644 --- a/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt +++ b/compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt @@ -159,9 +159,6 @@ open class JvmGeneratorExtensionsImpl(private val generateFacades: Boolean = tru override val shouldPreventDeprecatedIntegerValueTypeLiteralConversion: Boolean get() = true - private val flexibleNullabilityAnnotationClass = - createSpecialAnnotationClass(JvmSymbols.FLEXIBLE_NULLABILITY_ANNOTATION_FQ_NAME, kotlinIrInternalPackage) - private val rawTypeAnnotationClass = createSpecialAnnotationClass(JvmSymbols.RAW_TYPE_ANNOTATION_FQ_NAME, kotlinIrInternalPackage) @@ -170,7 +167,10 @@ open class JvmGeneratorExtensionsImpl(private val generateFacades: Boolean = tru createSpecialAnnotationClass(JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION, kotlinJvmInternalPackage) override val flexibleNullabilityAnnotationConstructor: IrConstructor = - flexibleNullabilityAnnotationClass.constructors.single() + createSpecialAnnotationClass(JvmSymbols.FLEXIBLE_NULLABILITY_ANNOTATION_FQ_NAME, kotlinIrInternalPackage).constructors.single() + + override val flexibleMutabilityAnnotationConstructor: IrConstructor = + createSpecialAnnotationClass(JvmSymbols.FLEXIBLE_MUTABILITY_ANNOTATION_FQ_NAME, kotlinIrInternalPackage).constructors.single() override val enhancedNullabilityAnnotationConstructor: IrConstructor = enhancedNullabilityAnnotationClass.constructors.single() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt index e8b678cb38c..b17cf1b58ca 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt @@ -899,6 +899,9 @@ class JvmSymbols( val FLEXIBLE_NULLABILITY_ANNOTATION_FQ_NAME = IrBuiltIns.KOTLIN_INTERNAL_IR_FQN.child(Name.identifier("FlexibleNullability")) + val FLEXIBLE_MUTABILITY_ANNOTATION_FQ_NAME = + IrBuiltIns.KOTLIN_INTERNAL_IR_FQN.child(Name.identifier("FlexibleMutability")) + val RAW_TYPE_ANNOTATION_FQ_NAME = IrBuiltIns.KOTLIN_INTERNAL_IR_FQN.child(Name.identifier("RawType")) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index 041d7f1b1b2..1f6f2f49712 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -362,6 +362,7 @@ abstract class AnnotationCodegen( internal val internalAnnotations = setOf( JvmSymbols.FLEXIBLE_NULLABILITY_ANNOTATION_FQ_NAME, + JvmSymbols.FLEXIBLE_MUTABILITY_ANNOTATION_FQ_NAME, JvmAnnotationNames.ENHANCED_NULLABILITY_ANNOTATION, JvmSymbols.RAW_TYPE_ANNOTATION_FQ_NAME ) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt index 30efd24dd11..09bfb909701 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt @@ -236,7 +236,14 @@ class IrBuiltIns( val stringType = string.toIrType() val stringClass = builtIns.string.toIrSymbol() + val iterableClass = builtIns.iterable.toIrSymbol() + val iteratorClass = builtIns.iterator.toIrSymbol() + val listIteratorClass = builtIns.listIterator.toIrSymbol() + val listClass = builtIns.list.toIrSymbol() val collectionClass = builtIns.collection.toIrSymbol() + val setClass = builtIns.set.toIrSymbol() + val mapClass = builtIns.map.toIrSymbol() + val mapEntryClass = builtIns.mapEntry.toIrSymbol() val arrayClass = builtIns.array.toIrSymbol() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt index db23bacbdca..b93c5099dde 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt @@ -36,15 +36,10 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon override fun KotlinTypeMarker.asSimpleType() = this as? SimpleTypeMarker - override fun KotlinTypeMarker.asFlexibleType(): FlexibleTypeMarker? { - if (this is FlexibleTypeMarker) return this - - if (this is IrType) { - val jvmFlexibleType = this.asJvmFlexibleType() - if (jvmFlexibleType != null) return jvmFlexibleType - } - - return null + override fun KotlinTypeMarker.asFlexibleType(): FlexibleTypeMarker? = when (this) { + is FlexibleTypeMarker -> this + is IrType -> asJvmFlexibleType(irBuiltIns) + else -> null } override fun KotlinTypeMarker.isError() = this is IrErrorType diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/jvmSpecificFlexibleTypes.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/jvmSpecificFlexibleTypes.kt index 7f927cc3ca6..43fd328fce1 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/jvmSpecificFlexibleTypes.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/jvmSpecificFlexibleTypes.kt @@ -5,35 +5,80 @@ package org.jetbrains.kotlin.ir.types +import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.types.impl.buildSimpleType +import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable import org.jetbrains.kotlin.ir.util.hasAnnotation +import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.FlexibleTypeBoundsChecker import org.jetbrains.kotlin.types.model.FlexibleTypeMarker -import org.jetbrains.kotlin.types.model.SimpleTypeMarker +// TODO: extract properly to JVM-specific modules internal interface IrJvmFlexibleType : FlexibleTypeMarker { - val lowerBound: SimpleTypeMarker - val upperBound: SimpleTypeMarker + val lowerBound: IrSimpleType + val upperBound: IrSimpleType } -internal class IrJvmFlexibleNullabilityType(val irType: IrSimpleType) : IrJvmFlexibleType { - override val lowerBound get() = irType.withHasQuestionMark(false) - override val upperBound get() = irType.withHasQuestionMark(true) +private class IrJvmFlexibleTypeImpl( + val irType: IrSimpleType, + val builtIns: IrBuiltIns, + val nullability: Boolean, + val mutability: Boolean +) : IrJvmFlexibleType { + override val lowerBound: IrSimpleType + get() = irType.buildSimpleType { + if (nullability) hasQuestionMark = false + // No change in classifier is needed for mutability because type's classifier is set to the lower bound anyway + // (see TypeTranslator.translateType). + kotlinType = null + } + + override val upperBound: IrSimpleType + get() = irType.buildSimpleType { + if (nullability) hasQuestionMark = true + if (mutability) { + val klass = classifier?.owner as? IrClass + ?: error("Mutability-flexible type's classifier is not a class: ${irType.render()}") + val readonlyClassFqName = FlexibleTypeBoundsChecker.getBaseBoundFqNameByMutability(klass.fqNameWhenAvailable!!) + classifier = when (readonlyClassFqName) { + StandardNames.FqNames.iterable -> builtIns.iterableClass + StandardNames.FqNames.iterator -> builtIns.iteratorClass + StandardNames.FqNames.listIterator -> builtIns.listIteratorClass + StandardNames.FqNames.list -> builtIns.listClass + StandardNames.FqNames.collection -> builtIns.collectionClass + StandardNames.FqNames.set -> builtIns.setClass + StandardNames.FqNames.map -> builtIns.mapClass + StandardNames.FqNames.mapEntry -> builtIns.mapEntryClass + else -> error("Mutability-flexible type with unknown classifier: ${irType.render()}, FQ name: $readonlyClassFqName") + } + } + kotlinType = null + } } -internal val FLEXIBLE_NULLABILITY_FQN = FqName("kotlin.internal.ir").child(Name.identifier("FlexibleNullability")) +internal val FLEXIBLE_NULLABILITY_FQN = FqName("kotlin.internal.ir.FlexibleNullability") +internal val FLEXIBLE_MUTABILITY_FQN = FqName("kotlin.internal.ir.FlexibleMutability") -internal fun IrType.isWithFlexibleNullability() = +internal fun IrType.isWithFlexibleNullability(): Boolean = hasAnnotation(FLEXIBLE_NULLABILITY_FQN) -internal fun IrType.asJvmFlexibleType() = - when { - this is IrSimpleType && isWithFlexibleNullability() -> - IrJvmFlexibleNullabilityType( - this.removeAnnotations { irCtorCall -> - irCtorCall.type.classFqName == FLEXIBLE_NULLABILITY_FQN - } as IrSimpleType - ) - else -> - null - } \ No newline at end of file +internal fun IrType.isWithFlexibleMutability(): Boolean = + hasAnnotation(FLEXIBLE_MUTABILITY_FQN) + +internal fun IrType.asJvmFlexibleType(builtIns: IrBuiltIns): FlexibleTypeMarker? { + if (this !is IrSimpleType || annotations.isEmpty()) return null + + val nullability = isWithFlexibleNullability() + val mutability = isWithFlexibleMutability() + if (!nullability && !mutability) return null + + val baseType = this.removeAnnotations { irCtorCall -> + val fqName = irCtorCall.type.classFqName + fqName == FLEXIBLE_NULLABILITY_FQN || fqName == FLEXIBLE_MUTABILITY_FQN + } as IrSimpleType + + return IrJvmFlexibleTypeImpl(baseType, builtIns, nullability, mutability) +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/StubGeneratorExtensions.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/StubGeneratorExtensions.kt index 8e30cdbf1be..3eb847a2b37 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/StubGeneratorExtensions.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/StubGeneratorExtensions.kt @@ -38,6 +38,9 @@ open class StubGeneratorExtensions { open val flexibleNullabilityAnnotationConstructor: IrConstructor? get() = null + open val flexibleMutabilityAnnotationConstructor: IrConstructor? + get() = null + open val enhancedNullabilityAnnotationConstructor: IrConstructor? get() = null diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt index ed0154967be..606b2e2bdb8 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt @@ -231,6 +231,9 @@ abstract class TypeTranslator( if (flexibleType.isNullabilityFlexible()) { irAnnotations.addSpecialAnnotation(extensions.flexibleNullabilityAnnotationConstructor) } + if (flexibleType.isMutabilityFlexible()) { + irAnnotations.addSpecialAnnotation(extensions.flexibleMutabilityAnnotationConstructor) + } if (flexibleType is RawType) { irAnnotations.addSpecialAnnotation(extensions.rawTypeAnnotationConstructor) @@ -239,6 +242,13 @@ abstract class TypeTranslator( return irAnnotations } + private fun KotlinType.isMutabilityFlexible(): Boolean { + val flexibility = unwrap() + return flexibility is FlexibleType && flexibility.lowerBound.constructor != flexibility.upperBound.constructor && + FlexibleTypeBoundsChecker.getBaseBoundFqNameByMutability(flexibility.lowerBound) == + FlexibleTypeBoundsChecker.getBaseBoundFqNameByMutability(flexibility.upperBound) + } + private fun MutableList.addSpecialAnnotation(irConstructor: IrConstructor?) { if (irConstructor != null) { add( diff --git a/compiler/testData/codegen/box/reflection/typeOf/flexibleTypes_after.kt b/compiler/testData/codegen/box/reflection/typeOf/flexibleTypes_after.kt index f2a8e31e370..9b8d2ee8bf6 100644 --- a/compiler/testData/codegen/box/reflection/typeOf/flexibleTypes_after.kt +++ b/compiler/testData/codegen/box/reflection/typeOf/flexibleTypes_after.kt @@ -1,7 +1,6 @@ // !API_VERSION: LATEST // !USE_EXPERIMENTAL: kotlin.ExperimentalStdlibApi // TARGET_BACKEND: JVM -// IGNORE_BACKEND: JVM_IR // IGNORE_BACKEND_FIR: JVM_IR // WITH_REFLECT // FILE: box.kt diff --git a/compiler/testData/ir/irText/firProblems/AllCandidates.txt b/compiler/testData/ir/irText/firProblems/AllCandidates.txt index d435cdb80ed..ff31f30e202 100644 --- a/compiler/testData/ir/irText/firProblems/AllCandidates.txt +++ b/compiler/testData/ir/irText/firProblems/AllCandidates.txt @@ -63,7 +63,7 @@ FILE fqName: fileName:/AllCandidates.kt FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:@[FlexibleNullability] .OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?>?) returnType:kotlin.Unit $receiver: VALUE_PARAMETER name:$this$apply type:@[FlexibleNullability] .OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?>? BLOCK_BODY - CALL 'public open fun setAllCandidates (allCandidates: @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] .ResolvedCall<@[FlexibleNullability] D of .OverloadResolutionResultsImpl?>?>?): kotlin.Unit declared in .OverloadResolutionResultsImpl' type=kotlin.Unit origin=EQ + CALL 'public open fun setAllCandidates (allCandidates: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] .ResolvedCall<@[FlexibleNullability] D of .OverloadResolutionResultsImpl?>?>?): kotlin.Unit declared in .OverloadResolutionResultsImpl' type=kotlin.Unit origin=EQ <1>: @[FlexibleNullability] A of .allCandidatesResult? $this: TYPE_OP type=.OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?> origin=IMPLICIT_NOTNULL typeOperand=.OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?> GET_VAR '$this$apply: @[FlexibleNullability] .OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?>? declared in .allCandidatesResult.' type=@[FlexibleNullability] .OverloadResolutionResultsImpl<@[FlexibleNullability] A of .allCandidatesResult?>? origin=null diff --git a/compiler/testData/ir/irText/firProblems/SyntheticSetterType.txt b/compiler/testData/ir/irText/firProblems/SyntheticSetterType.txt index bd2fffebf24..01455b58d49 100644 --- a/compiler/testData/ir/irText/firProblems/SyntheticSetterType.txt +++ b/compiler/testData/ir/irText/firProblems/SyntheticSetterType.txt @@ -2,7 +2,7 @@ FILE fqName: fileName:/SyntheticSetterType.kt FUN name:foo visibility:public modality:FINAL <> (descriptor:.PropertyDescriptorImpl) returnType:kotlin.Unit VALUE_PARAMETER name:descriptor index:0 type:.PropertyDescriptorImpl BLOCK_BODY - CALL 'public open fun setOverriddenDescriptors (overriddenDescriptors: @[EnhancedNullability] kotlin.collections.MutableCollection.CallableMemberDescriptor?>): kotlin.Unit declared in .PropertyDescriptorImpl' type=kotlin.Unit origin=EQ + CALL 'public open fun setOverriddenDescriptors (overriddenDescriptors: @[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableCollection.CallableMemberDescriptor?>): kotlin.Unit declared in .PropertyDescriptorImpl' type=kotlin.Unit origin=EQ $this: GET_VAR 'descriptor: .PropertyDescriptorImpl declared in .foo' type=.PropertyDescriptorImpl origin=null overriddenDescriptors: CALL 'public final fun emptyList (): kotlin.collections.List declared in kotlin.collections.CollectionsKt' type=kotlin.collections.List<@[FlexibleNullability] .PropertyDescriptor?> origin=null : @[FlexibleNullability] .PropertyDescriptor? diff --git a/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.kt.txt b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.kt.txt index 2efbc70e543..c9a25809c3f 100644 --- a/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.kt.txt +++ b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.kt.txt @@ -1,5 +1,5 @@ fun problematic(lss: List>): List { - return lss.flatMap, @FlexibleNullability T?>(transform = local fun (it: List): @EnhancedNullability MutableList<@FlexibleNullability T?> { + return lss.flatMap, @FlexibleNullability T?>(transform = local fun (it: List): @EnhancedNullability @FlexibleMutability MutableList<@FlexibleNullability T?> { return id<@FlexibleNullability T?>(v = it) /*!! List<@FlexibleNullability T?> */ } ) diff --git a/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.txt b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.txt index 97d6f871708..ee571105f5c 100644 --- a/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.txt +++ b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.txt @@ -8,12 +8,12 @@ FILE fqName: fileName:/typeParametersInImplicitCast.kt : kotlin.collections.List.problematic> : @[FlexibleNullability] T of .problematic? $receiver: GET_VAR 'lss: kotlin.collections.List.problematic>> declared in .problematic' type=kotlin.collections.List.problematic>> origin=null - transform: FUN_EXPR type=kotlin.Function1.problematic>, @[EnhancedNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?>> origin=LAMBDA - FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> (it:kotlin.collections.List.problematic>) returnType:@[EnhancedNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> + transform: FUN_EXPR type=kotlin.Function1.problematic>, @[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?>> origin=LAMBDA + FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> (it:kotlin.collections.List.problematic>) returnType:@[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> VALUE_PARAMETER name:it index:0 type:kotlin.collections.List.problematic> BLOCK_BODY - RETURN type=kotlin.Nothing from='local final fun (it: kotlin.collections.List.problematic>): @[EnhancedNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> declared in .problematic' + RETURN type=kotlin.Nothing from='local final fun (it: kotlin.collections.List.problematic>): @[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> declared in .problematic' TYPE_OP type=kotlin.collections.List<@[FlexibleNullability] T of .problematic?> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[FlexibleNullability] T of .problematic?> - CALL 'public/*package*/ open fun id (v: @[FlexibleNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .ListId.id?>?): @[EnhancedNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .ListId.id?> declared in .ListId' type=@[EnhancedNullability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> origin=null + CALL 'public/*package*/ open fun id (v: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .ListId.id?>?): @[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .ListId.id?> declared in .ListId' type=@[EnhancedNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[FlexibleNullability] T of .problematic?> origin=null : @[FlexibleNullability] T of .problematic? v: GET_VAR 'it: kotlin.collections.List.problematic> declared in .problematic.' type=kotlin.collections.List.problematic> origin=null diff --git a/compiler/testData/ir/irText/stubs/builtinMap.txt b/compiler/testData/ir/irText/stubs/builtinMap.txt index 1f84835c0e7..db6bf75d96f 100644 --- a/compiler/testData/ir/irText/stubs/builtinMap.txt +++ b/compiler/testData/ir/irText/stubs/builtinMap.txt @@ -18,7 +18,7 @@ FILE fqName: fileName:/builtinMap.kt if: CONST Boolean type=kotlin.Boolean value=true then: CALL 'public final fun apply (block: @[ExtensionFunctionType] kotlin.Function1): T of kotlin.StandardKt.apply [inline] declared in kotlin.StandardKt' type=java.util.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?>{ kotlin.collections.TypeAliasesKt.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?> } origin=null : java.util.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?>{ kotlin.collections.TypeAliasesKt.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?> } - $receiver: CONSTRUCTOR_CALL 'public constructor (p0: @[FlexibleNullability] kotlin.collections.MutableMap?) declared in java.util.LinkedHashMap' type=java.util.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?> origin=null + $receiver: CONSTRUCTOR_CALL 'public constructor (p0: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableMap?) declared in java.util.LinkedHashMap' type=java.util.LinkedHashMap<@[FlexibleNullability] K1 of .plus?, @[FlexibleNullability] V1 of .plus?> origin=null : @[FlexibleNullability] K1 of .plus? : @[FlexibleNullability] V1 of .plus? p0: GET_VAR ': kotlin.collections.Map.plus, V1 of .plus> declared in .plus' type=kotlin.collections.Map.plus, V1 of .plus> origin=null diff --git a/compiler/testData/ir/irText/types/javaWildcardType.kt.txt b/compiler/testData/ir/irText/types/javaWildcardType.kt.txt index e5ad5568f40..2586205c6ca 100644 --- a/compiler/testData/ir/irText/types/javaWildcardType.kt.txt +++ b/compiler/testData/ir/irText/types/javaWildcardType.kt.txt @@ -14,19 +14,19 @@ class C : J, K { } private /* final field */ val $$delegate_0: J = j - override fun jf1(): @FlexibleNullability MutableCollection? { + override fun jf1(): @FlexibleNullability @FlexibleMutability MutableCollection? { return .#$$delegate_0.jf1() } - override fun jf2(): @FlexibleNullability MutableCollection<@FlexibleNullability CharSequence?>? { + override fun jf2(): @FlexibleNullability @FlexibleMutability MutableCollection<@FlexibleNullability CharSequence?>? { return .#$$delegate_0.jf2() } - override fun jg1(c: @FlexibleNullability MutableCollection?) { + override fun jg1(c: @FlexibleNullability @FlexibleMutability MutableCollection?) { .#$$delegate_0.jg1(c = c) } - override fun jg2(c: @FlexibleNullability MutableCollection<@FlexibleNullability CharSequence?>?) { + override fun jg2(c: @FlexibleNullability @FlexibleMutability MutableCollection<@FlexibleNullability CharSequence?>?) { .#$$delegate_0.jg2(c = c) } diff --git a/compiler/testData/ir/irText/types/javaWildcardType.txt b/compiler/testData/ir/irText/types/javaWildcardType.txt index baf1c313a6a..94affa992ba 100644 --- a/compiler/testData/ir/irText/types/javaWildcardType.txt +++ b/compiler/testData/ir/irText/types/javaWildcardType.txt @@ -35,44 +35,44 @@ FILE fqName: fileName:/javaWildcardType.kt FIELD DELEGATE name:$$delegate_0 type:.J visibility:private [final] EXPRESSION_BODY GET_VAR 'j: .J declared in .C.' type=.J origin=null - FUN DELEGATED_MEMBER name:jf1 visibility:public modality:OPEN <> ($this:.C) returnType:@[FlexibleNullability] kotlin.collections.MutableCollection? + FUN DELEGATED_MEMBER name:jf1 visibility:public modality:OPEN <> ($this:.C) returnType:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? overridden: - public abstract fun jf1 (): @[FlexibleNullability] kotlin.collections.MutableCollection? declared in .J + public abstract fun jf1 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? declared in .J $this: VALUE_PARAMETER name: type:.C BLOCK_BODY - RETURN type=kotlin.Nothing from='public open fun jf1 (): @[FlexibleNullability] kotlin.collections.MutableCollection? declared in .C' - CALL 'public abstract fun jf1 (): @[FlexibleNullability] kotlin.collections.MutableCollection? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableCollection? origin=null + RETURN type=kotlin.Nothing from='public open fun jf1 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? declared in .C' + CALL 'public abstract fun jf1 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.J visibility:private [final]' type=.J origin=null receiver: GET_VAR ': .C declared in .C.jf1' type=.C origin=null - FUN DELEGATED_MEMBER name:jf2 visibility:public modality:OPEN <> ($this:.C) returnType:@[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? + FUN DELEGATED_MEMBER name:jf2 visibility:public modality:OPEN <> ($this:.C) returnType:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? overridden: - public abstract fun jf2 (): @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .J + public abstract fun jf2 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .J $this: VALUE_PARAMETER name: type:.C BLOCK_BODY - RETURN type=kotlin.Nothing from='public open fun jf2 (): @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .C' - CALL 'public abstract fun jf2 (): @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? origin=null + RETURN type=kotlin.Nothing from='public open fun jf2 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .C' + CALL 'public abstract fun jf2 (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.J visibility:private [final]' type=.J origin=null receiver: GET_VAR ': .C declared in .C.jf2' type=.C origin=null - FUN DELEGATED_MEMBER name:jg1 visibility:public modality:OPEN <> ($this:.C, c:@[FlexibleNullability] kotlin.collections.MutableCollection?) returnType:kotlin.Unit + FUN DELEGATED_MEMBER name:jg1 visibility:public modality:OPEN <> ($this:.C, c:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection?) returnType:kotlin.Unit overridden: - public abstract fun jg1 (c: @[FlexibleNullability] kotlin.collections.MutableCollection?): kotlin.Unit declared in .J + public abstract fun jg1 (c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection?): kotlin.Unit declared in .J $this: VALUE_PARAMETER name: type:.C - VALUE_PARAMETER name:c index:0 type:@[FlexibleNullability] kotlin.collections.MutableCollection? + VALUE_PARAMETER name:c index:0 type:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? BLOCK_BODY - CALL 'public abstract fun jg1 (c: @[FlexibleNullability] kotlin.collections.MutableCollection?): kotlin.Unit declared in .J' type=kotlin.Unit origin=null + CALL 'public abstract fun jg1 (c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection?): kotlin.Unit declared in .J' type=kotlin.Unit origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.J visibility:private [final]' type=.J origin=null receiver: GET_VAR ': .C declared in .C.jg1' type=.C origin=null - c: GET_VAR 'c: @[FlexibleNullability] kotlin.collections.MutableCollection? declared in .C.jg1' type=@[FlexibleNullability] kotlin.collections.MutableCollection? origin=null - FUN DELEGATED_MEMBER name:jg2 visibility:public modality:OPEN <> ($this:.C, c:@[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?) returnType:kotlin.Unit + c: GET_VAR 'c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? declared in .C.jg1' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection? origin=null + FUN DELEGATED_MEMBER name:jg2 visibility:public modality:OPEN <> ($this:.C, c:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?) returnType:kotlin.Unit overridden: - public abstract fun jg2 (c: @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?): kotlin.Unit declared in .J + public abstract fun jg2 (c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?): kotlin.Unit declared in .J $this: VALUE_PARAMETER name: type:.C - VALUE_PARAMETER name:c index:0 type:@[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? + VALUE_PARAMETER name:c index:0 type:@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? BLOCK_BODY - CALL 'public abstract fun jg2 (c: @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?): kotlin.Unit declared in .J' type=kotlin.Unit origin=null + CALL 'public abstract fun jg2 (c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>?): kotlin.Unit declared in .J' type=kotlin.Unit origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.J visibility:private [final]' type=.J origin=null receiver: GET_VAR ': .C declared in .C.jg2' type=.C origin=null - c: GET_VAR 'c: @[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .C.jg2' type=@[FlexibleNullability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? origin=null + c: GET_VAR 'c: @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? declared in .C.jg2' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableCollection<@[FlexibleNullability] kotlin.CharSequence?>? origin=null FIELD DELEGATE name:$$delegate_1 type:.K visibility:private [final] EXPRESSION_BODY GET_VAR 'k: .K declared in .C.' type=.K origin=null diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.txt index b35ef0bb0bd..c3cfc210e77 100644 --- a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.txt +++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.txt @@ -193,7 +193,7 @@ FILE fqName: fileName:/enhancedNullabilityInDestructuringAssignment.kt $receiver: CALL 'public final fun withIndex (): kotlin.collections.Iterable> declared in kotlin.collections.CollectionsKt' type=kotlin.collections.Iterable)] @[EnhancedNullability] .P>> origin=null : @[NotNull(value = )] @[EnhancedNullability] .P $receiver: TYPE_OP type=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> - CALL 'public open fun listOfNotNull (): @[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null + CALL 'public open fun listOfNotNull (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null VAR name:x type:kotlin.Int [val] CALL 'public final fun component1 (): kotlin.Int [operator] declared in kotlin.collections.IndexedValue' type=kotlin.Int origin=COMPONENT_N(index=1) $this: GET_VAR 'val tmp_3: kotlin.collections.IndexedValue<@[NotNull(value = )] @[EnhancedNullability] .P> [val] declared in .test4' type=kotlin.collections.IndexedValue<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.txt index 3eba36ebb98..64eb25ebfcf 100644 --- a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.txt +++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.txt @@ -9,7 +9,7 @@ FILE fqName: fileName:/enhancedNullabilityInForLoop.kt CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator [fake_override,operator] declared in kotlin.collections.MutableList' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=FOR_LOOP_ITERATOR $this: TYPE_OP type=kotlin.collections.MutableList<*> origin=IMPLICIT_CAST typeOperand=kotlin.collections.MutableList<*> TYPE_OP type=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> - CALL 'public open fun listOfNotNull (): @[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null + CALL 'public open fun listOfNotNull (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null WHILE label=null origin=FOR_LOOP_INNER_WHILE condition: CALL 'public abstract fun hasNext (): kotlin.Boolean [fake_override,operator] declared in kotlin.collections.MutableIterator' type=kotlin.Boolean origin=FOR_LOOP_HAS_NEXT $this: GET_VAR 'val tmp_0: kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> [val] declared in .testForInListUnused' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null @@ -25,7 +25,7 @@ FILE fqName: fileName:/enhancedNullabilityInForLoop.kt CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator [fake_override,operator] declared in kotlin.collections.MutableList' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=FOR_LOOP_ITERATOR $this: TYPE_OP type=kotlin.collections.MutableList<*> origin=IMPLICIT_CAST typeOperand=kotlin.collections.MutableList<*> TYPE_OP type=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> - CALL 'public open fun listOfNotNull (): @[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null + CALL 'public open fun listOfNotNull (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null WHILE label=null origin=FOR_LOOP_INNER_WHILE condition: CALL 'public abstract fun hasNext (): kotlin.Boolean [fake_override,operator] declared in kotlin.collections.MutableIterator' type=kotlin.Boolean origin=FOR_LOOP_HAS_NEXT $this: GET_VAR 'val tmp_1: kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> [val] declared in .testForInListDestructured' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null @@ -48,7 +48,7 @@ FILE fqName: fileName:/enhancedNullabilityInForLoop.kt CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator [fake_override,operator] declared in kotlin.collections.MutableList' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null $this: TYPE_OP type=kotlin.collections.MutableList<*> origin=IMPLICIT_CAST typeOperand=kotlin.collections.MutableList<*> TYPE_OP type=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> - CALL 'public open fun listOfNotNull (): @[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null + CALL 'public open fun listOfNotNull (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null WHILE label=null origin=WHILE_LOOP condition: CALL 'public abstract fun hasNext (): kotlin.Boolean [fake_override,operator] declared in kotlin.collections.MutableIterator' type=kotlin.Boolean origin=null $this: GET_VAR 'val iterator: kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> [val] declared in .testDesugaredForInList' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null @@ -82,7 +82,7 @@ FILE fqName: fileName:/enhancedNullabilityInForLoop.kt CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator [fake_override,operator] declared in kotlin.collections.MutableList' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=FOR_LOOP_ITERATOR $this: TYPE_OP type=kotlin.collections.MutableList<*> origin=IMPLICIT_CAST typeOperand=kotlin.collections.MutableList<*> TYPE_OP type=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<@[NotNull(value = )] @[EnhancedNullability] .P> - CALL 'public open fun listOfNotNull (): @[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null + CALL 'public open fun listOfNotNull (): @[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? declared in .J' type=@[FlexibleNullability] @[FlexibleMutability] kotlin.collections.MutableList<@[NotNull(value = )] @[EnhancedNullability] .P>? origin=null WHILE label=null origin=FOR_LOOP_INNER_WHILE condition: CALL 'public abstract fun hasNext (): kotlin.Boolean [fake_override,operator] declared in kotlin.collections.MutableIterator' type=kotlin.Boolean origin=FOR_LOOP_HAS_NEXT $this: GET_VAR 'val tmp_4: kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> [val] declared in .testForInListUse' type=kotlin.collections.MutableIterator<@[NotNull(value = )] @[EnhancedNullability] .P> origin=null diff --git a/compiler/testData/ir/irText/types/rawTypeInSignature.kt.txt b/compiler/testData/ir/irText/types/rawTypeInSignature.kt.txt index d39267cfd70..5af6c0c98a8 100644 --- a/compiler/testData/ir/irText/types/rawTypeInSignature.kt.txt +++ b/compiler/testData/ir/irText/types/rawTypeInSignature.kt.txt @@ -57,7 +57,7 @@ class KRaw : JRaw { return .#$$delegate_0.returnsRawGenericOut() } - override fun returnsRawList(): @FlexibleNullability @RawType MutableList? { + override fun returnsRawList(): @FlexibleNullability @FlexibleMutability @RawType MutableList? { return .#$$delegate_0.returnsRawList() } @@ -73,7 +73,7 @@ class KRaw : JRaw { .#$$delegate_0.takesRawGenericOut(g = g) } - override fun takesRawList(list: @FlexibleNullability @RawType MutableList?) { + override fun takesRawList(list: @FlexibleNullability @FlexibleMutability @RawType MutableList?) { .#$$delegate_0.takesRawList(list = list) } diff --git a/compiler/testData/ir/irText/types/rawTypeInSignature.txt b/compiler/testData/ir/irText/types/rawTypeInSignature.txt index 5b7c302c9c7..b7826a66429 100644 --- a/compiler/testData/ir/irText/types/rawTypeInSignature.txt +++ b/compiler/testData/ir/irText/types/rawTypeInSignature.txt @@ -114,13 +114,13 @@ FILE fqName: fileName:/rawTypeInSignature.kt CALL 'public abstract fun returnsRawGenericOut (): @[FlexibleNullability] @[RawType] .GenericOut? declared in .JRaw' type=@[FlexibleNullability] @[RawType] .GenericOut? origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.JRaw visibility:private [final]' type=.JRaw origin=null receiver: GET_VAR ': .KRaw declared in .KRaw.returnsRawGenericOut' type=.KRaw origin=null - FUN DELEGATED_MEMBER name:returnsRawList visibility:public modality:OPEN <> ($this:.KRaw) returnType:@[FlexibleNullability] @[RawType] kotlin.collections.MutableList? + FUN DELEGATED_MEMBER name:returnsRawList visibility:public modality:OPEN <> ($this:.KRaw) returnType:@[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? overridden: - public abstract fun returnsRawList (): @[FlexibleNullability] @[RawType] kotlin.collections.MutableList? declared in .JRaw + public abstract fun returnsRawList (): @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? declared in .JRaw $this: VALUE_PARAMETER name: type:.KRaw BLOCK_BODY - RETURN type=kotlin.Nothing from='public open fun returnsRawList (): @[FlexibleNullability] @[RawType] kotlin.collections.MutableList? declared in .KRaw' - CALL 'public abstract fun returnsRawList (): @[FlexibleNullability] @[RawType] kotlin.collections.MutableList? declared in .JRaw' type=@[FlexibleNullability] @[RawType] kotlin.collections.MutableList? origin=null + RETURN type=kotlin.Nothing from='public open fun returnsRawList (): @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? declared in .KRaw' + CALL 'public abstract fun returnsRawList (): @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? declared in .JRaw' type=@[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.JRaw visibility:private [final]' type=.JRaw origin=null receiver: GET_VAR ': .KRaw declared in .KRaw.returnsRawList' type=.KRaw origin=null FUN DELEGATED_MEMBER name:takesRawGenericIn visibility:public modality:OPEN <> ($this:.KRaw, g:@[FlexibleNullability] @[RawType] .GenericIn?) returnType:kotlin.Unit @@ -153,16 +153,16 @@ FILE fqName: fileName:/rawTypeInSignature.kt $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.JRaw visibility:private [final]' type=.JRaw origin=null receiver: GET_VAR ': .KRaw declared in .KRaw.takesRawGenericOut' type=.KRaw origin=null g: GET_VAR 'g: @[FlexibleNullability] @[RawType] .GenericOut? declared in .KRaw.takesRawGenericOut' type=@[FlexibleNullability] @[RawType] .GenericOut? origin=null - FUN DELEGATED_MEMBER name:takesRawList visibility:public modality:OPEN <> ($this:.KRaw, list:@[FlexibleNullability] @[RawType] kotlin.collections.MutableList?) returnType:kotlin.Unit + FUN DELEGATED_MEMBER name:takesRawList visibility:public modality:OPEN <> ($this:.KRaw, list:@[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList?) returnType:kotlin.Unit overridden: - public abstract fun takesRawList (list: @[FlexibleNullability] @[RawType] kotlin.collections.MutableList?): kotlin.Unit declared in .JRaw + public abstract fun takesRawList (list: @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList?): kotlin.Unit declared in .JRaw $this: VALUE_PARAMETER name: type:.KRaw - VALUE_PARAMETER name:list index:0 type:@[FlexibleNullability] @[RawType] kotlin.collections.MutableList? + VALUE_PARAMETER name:list index:0 type:@[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? BLOCK_BODY - CALL 'public abstract fun takesRawList (list: @[FlexibleNullability] @[RawType] kotlin.collections.MutableList?): kotlin.Unit declared in .JRaw' type=kotlin.Unit origin=null + CALL 'public abstract fun takesRawList (list: @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList?): kotlin.Unit declared in .JRaw' type=kotlin.Unit origin=null $this: GET_FIELD 'FIELD DELEGATE name:$$delegate_0 type:.JRaw visibility:private [final]' type=.JRaw origin=null receiver: GET_VAR ': .KRaw declared in .KRaw.takesRawList' type=.KRaw origin=null - list: GET_VAR 'list: @[FlexibleNullability] @[RawType] kotlin.collections.MutableList? declared in .KRaw.takesRawList' type=@[FlexibleNullability] @[RawType] kotlin.collections.MutableList? origin=null + list: GET_VAR 'list: @[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? declared in .KRaw.takesRawList' type=@[FlexibleNullability] @[FlexibleMutability] @[RawType] kotlin.collections.MutableList? origin=null FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] overridden: public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .JRaw diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt index deeb9e9bb3d..ebd7b37c183 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt @@ -174,12 +174,11 @@ object FlexibleTypeBoundsChecker { return possiblePairBound == b.constructor.declarationDescriptor?.fqNameSafe } - // We consider base bounds as not mutable collections - fun getBaseBoundFqNameByMutability(a: KotlinType): FqName? { - val fqName = a.constructor.declarationDescriptor?.fqNameSafe ?: return null + // We consider base bounds as readonly collection interfaces (e.g. kotlin.collections.Iterable). + fun getBaseBoundFqNameByMutability(type: KotlinType): FqName? = + type.constructor.declarationDescriptor?.fqNameSafe?.let(::getBaseBoundFqNameByMutability) - if (fqName in baseTypesToMutableEquivalent) return fqName - - return mutableToBaseMap[fqName] - } + fun getBaseBoundFqNameByMutability(fqName: FqName): FqName? = + if (fqName in baseTypesToMutableEquivalent) fqName + else mutableToBaseMap[fqName] }