From 3f6738c8bc50a97a0b6d3fe222fbbe8e81f65a3c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 25 Aug 2021 13:43:01 +0300 Subject: [PATCH] Remove all type system dependent methods from TypeCheckerState --- .../kotlin/fir/types/ConeTypeContext.kt | 35 +++++++++++-------- .../types/FirCorrespondingSupertypesCache.kt | 4 +-- .../kotlin/ir/types/IrTypeCheckerState.kt | 15 +------- .../kotlin/ir/types/IrTypeSystemContext.kt | 17 +++++++++ .../components/ConstraintInjector.kt | 4 --- .../TypeCheckerStateForConstraintSystem.kt | 2 +- .../kotlin/types/AbstractTypeChecker.kt | 12 +++---- .../kotlin/types/model/TypeSystemContext.kt | 4 +++ .../OverridingUtilTypeSystemContext.kt | 1 - .../types/checker/ClassicTypeCheckerState.kt | 28 ++------------- .../types/checker/ClassicTypeSystemContext.kt | 18 ++++++++++ 11 files changed, 71 insertions(+), 69 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index ca1df2bf9db..d2f9adb15d0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -566,20 +566,8 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty private fun TypeConstructorMarker.unknownConstructorError(): Nothing { error("Unknown type constructor: ${this::class}") } -} -class ConeTypeCheckerState( - override val isErrorTypeEqualsToAnything: Boolean, - override val isStubTypeEqualsToAnything: Boolean, - override val typeSystemContext: ConeInferenceContext, - override val kotlinTypePreparator: ConeTypePreparator = ConeTypePreparator(typeSystemContext.session), -) : TypeCheckerState() { - override val kotlinTypeRefiner: AbstractTypeRefiner - get() = AbstractTypeRefiner.Default - - val session: FirSession = typeSystemContext.session - - override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy = with(typeSystemContext) { + override fun substitutionSupertypePolicy(type: SimpleTypeMarker): TypeCheckerState.SupertypesPolicy { if (type.argumentsCount() == 0) return LowerIfFlexible require(type is ConeKotlinType) val declaration = when (type) { @@ -607,6 +595,23 @@ class ConeTypeCheckerState( } } - override val KotlinTypeMarker.isAllowedTypeVariable: Boolean - get() = this is ConeKotlinType && this is ConeTypeVariableType + override fun KotlinTypeMarker.isTypeVariableType(): Boolean { + return this is ConeTypeVariableType + } +} + +class ConeTypeCheckerState( + override val isErrorTypeEqualsToAnything: Boolean, + override val isStubTypeEqualsToAnything: Boolean, + override val typeSystemContext: ConeInferenceContext, + override val kotlinTypePreparator: ConeTypePreparator = ConeTypePreparator(typeSystemContext.session), +) : TypeCheckerState() { + override val kotlinTypeRefiner: AbstractTypeRefiner + get() = AbstractTypeRefiner.Default + + val session: FirSession = typeSystemContext.session + + + override val allowedTypeVariable: Boolean + get() = true } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt index fe6b4fcc775..75f0d33d47b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/FirCorrespondingSupertypesCache.kt @@ -44,7 +44,7 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess if (type.typeArguments.isEmpty()) return resultTypes val capturedType = captureType(type, typeCheckerState.typeSystemContext) - val substitutionSupertypePolicy = typeCheckerState.substitutionSupertypePolicy(capturedType) + val substitutionSupertypePolicy = typeCheckerState.typeSystemContext.substitutionSupertypePolicy(capturedType) return resultTypes.map { substitutionSupertypePolicy.transformType(typeCheckerState, it) as ConeClassLikeType } @@ -97,7 +97,7 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess TypeCheckerState.SupertypesPolicy.LowerIfFlexible } else -> { - state.substitutionSupertypePolicy(captured) + state.typeSystemContext.substitutionSupertypePolicy(captured) } } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerState.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerState.kt index 1a6dd3a9d36..0c741ce74e5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerState.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerState.kt @@ -22,22 +22,9 @@ open class IrTypeCheckerState(override val typeSystemContext: IrTypeSystemContex val irBuiltIns: IrBuiltIns get() = typeSystemContext.irBuiltIns - override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy.DoCustomTransform { - require(type is IrSimpleType) - val parameters = extractTypeParameters((type.classifier as IrClassSymbol).owner).map { it.symbol } - val typeSubstitutor = IrTypeSubstitutor(parameters, type.arguments, irBuiltIns) - - return object : SupertypesPolicy.DoCustomTransform() { - override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker { - require(type is IrType) - return typeSubstitutor.substitute(type) as IrSimpleType - } - } - } - override val isErrorTypeEqualsToAnything get() = false override val isStubTypeEqualsToAnything get() = false - override val KotlinTypeMarker.isAllowedTypeVariable: Boolean + override val allowedTypeVariable: Boolean get() = false } 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 b269108bb88..947aa5ffad6 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 @@ -528,6 +528,23 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon override fun SimpleTypeMarker.makeSimpleTypeDefinitelyNotNullOrNotNull(): SimpleTypeMarker { error("makeSimpleTypeDefinitelyNotNullOrNotNull is not yet supported in IR") } + + override fun substitutionSupertypePolicy(type: SimpleTypeMarker): TypeCheckerState.SupertypesPolicy { + require(type is IrSimpleType) + val parameters = extractTypeParameters((type.classifier as IrClassSymbol).owner).map { it.symbol } + val typeSubstitutor = IrTypeSubstitutor(parameters, type.arguments, irBuiltIns) + + return object : TypeCheckerState.SupertypesPolicy.DoCustomTransform() { + override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker { + require(type is IrType) + return typeSubstitutor.substitute(type) as IrSimpleType + } + } + } + + override fun KotlinTypeMarker.isTypeVariableType(): Boolean { + return false + } } fun extractTypeParameters(parent: IrDeclarationParent): List { diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt index 715e53f2ca0..3e6f939f8df 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt @@ -250,10 +250,6 @@ class ConstraintInjector( val baseState: TypeCheckerState = newTypeCheckerState(isErrorTypeEqualsToAnything, isStubTypeEqualsToAnything) - override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy { - return baseState.substitutionSupertypePolicy(type) - } - fun runIsSubtypeOf( lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker, diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/TypeCheckerStateForConstraintSystem.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/TypeCheckerStateForConstraintSystem.kt index 1ddd98b8009..b809d86a20f 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/TypeCheckerStateForConstraintSystem.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/TypeCheckerStateForConstraintSystem.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.types.model.* abstract class TypeCheckerStateForConstraintSystem(override val typeSystemContext: TypeSystemInferenceExtensionContext) : TypeCheckerState() { - override val KotlinTypeMarker.isAllowedTypeVariable: Boolean + override val allowedTypeVariable: Boolean get() = false override val isErrorTypeEqualsToAnything: Boolean diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt index 1f69fb38ef9..011cd27e468 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.types +import org.jetbrains.kotlin.descriptors.containerRelation import org.jetbrains.kotlin.types.TypeCheckerState.LowerCapturedTypePolicy.* import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy import org.jetbrains.kotlin.types.model.* @@ -27,7 +28,7 @@ abstract class TypeCheckerState { abstract val typeSystemContext: TypeSystemContext - abstract fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy + abstract val allowedTypeVariable: Boolean @OptIn(TypeRefinement::class) fun refineType(type: KotlinTypeMarker): KotlinTypeMarker { @@ -157,10 +158,9 @@ abstract class TypeCheckerState { abstract class DoCustomTransform : SupertypesPolicy() } - abstract val KotlinTypeMarker.isAllowedTypeVariable: Boolean - - @JvmName("isAllowedTypeVariableBridge") - fun isAllowedTypeVariable(type: KotlinTypeMarker): Boolean = type.isAllowedTypeVariable + fun isAllowedTypeVariable(type: KotlinTypeMarker): Boolean { + return allowedTypeVariable && with(typeSystemContext) { type.isTypeVariableType() } + } } object AbstractTypeChecker { @@ -596,7 +596,7 @@ object AbstractTypeChecker { SupertypesPolicy.LowerIfFlexible } else -> { - state.substitutionSupertypePolicy(current) + state.typeSystemContext.substitutionSupertypePolicy(current) } } } diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt index 9ffe817ea11..4be9e1dd7cc 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt @@ -461,6 +461,10 @@ interface TypeSystemContext : TypeSystemOptimizationContext { fun SimpleTypeMarker.isPrimitiveType(): Boolean fun KotlinTypeMarker.getAnnotations(): List + + fun substitutionSupertypePolicy(type: SimpleTypeMarker): TypeCheckerState.SupertypesPolicy + + fun KotlinTypeMarker.isTypeVariableType(): Boolean } enum class CaptureStatus { diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtilTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtilTypeSystemContext.kt index d16844000e2..84daf72c074 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtilTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtilTypeSystemContext.kt @@ -32,7 +32,6 @@ class OverridingUtilTypeSystemContext( return ClassicTypeCheckerState( errorTypesEqualToAnything, stubTypesEqualToAnything, - allowedTypeVariable = true, kotlinTypeRefiner, typeSystemContext = this ) diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeCheckerState.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeCheckerState.kt index 8d5fc687e2e..e17ac9c8d21 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeCheckerState.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeCheckerState.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.types.model.SimpleTypeMarker open class ClassicTypeCheckerState( val errorTypeEqualsToAnything: Boolean, val stubTypeEqualsToAnything: Boolean = true, - val allowedTypeVariable: Boolean = true, override val kotlinTypeRefiner: KotlinTypeRefiner = KotlinTypeRefiner.Default, override val kotlinTypePreparator: KotlinTypePreparator = KotlinTypePreparator.Default, override val typeSystemContext: ClassicTypeSystemContext = SimpleClassicTypeSystemContext @@ -34,29 +33,6 @@ open class ClassicTypeCheckerState( override val isStubTypeEqualsToAnything: Boolean get() = stubTypeEqualsToAnything - override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy.DoCustomTransform { - return typeSystemContext.classicSubstitutionSupertypePolicy(type) - } - - override val KotlinTypeMarker.isAllowedTypeVariable: Boolean get() = this is UnwrappedType && allowedTypeVariable && constructor is NewTypeVariableConstructor - - companion object { - fun ClassicTypeSystemContext.classicSubstitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy.DoCustomTransform { - require(type is SimpleType, type::errorMessage) - val substitutor = TypeConstructorSubstitution.create(type).buildSubstitutor() - - return object : SupertypesPolicy.DoCustomTransform() { - override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker { - return substitutor.safeSubstitute( - type.lowerBoundIfFlexible() as KotlinType, - Variance.INVARIANT - ).asSimpleType()!! - } - } - } - } -} - -private fun Any.errorMessage(): String { - return "ClassicTypeCheckerContext couldn't handle ${this::class} $this" + override val allowedTypeVariable: Boolean + get() = true } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index 75a323a7ff4..aaa6fe1284d 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt @@ -788,6 +788,24 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy } else { createFlexibleType(this, this.withNullability(true)) } + + override fun substitutionSupertypePolicy(type: SimpleTypeMarker): TypeCheckerState.SupertypesPolicy { + require(type is SimpleType, type::errorMessage) + val substitutor = TypeConstructorSubstitution.create(type).buildSubstitutor() + + return object : TypeCheckerState.SupertypesPolicy.DoCustomTransform() { + override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker { + return substitutor.safeSubstitute( + type.lowerBoundIfFlexible() as KotlinType, + Variance.INVARIANT + ).asSimpleType()!! + } + } + } + + override fun KotlinTypeMarker.isTypeVariableType(): Boolean { + return this is UnwrappedType && constructor is NewTypeVariableConstructor + } } fun TypeVariance.convertVariance(): Variance {