Decouple TypeCheckerContext and TypeSystemContext

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt

@@ -1374,7 +1374,7 @@ class ExpressionCodegen(
         val reifiedTypeInliner = ReifiedTypeInliner(
             mappings,
             IrInlineIntrinsicsSupport(context, typeMapper),
-            IrTypeCheckerContext(context.irBuiltIns),
+            IrTypeSystemContextImpl(context.irBuiltIns),
             state.languageVersionSettings,
             state.unifiedNullChecks,
         )

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrTypeMapper.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.ir.types.isKClass as isKClassImpl
 import org.jetbrains.kotlin.ir.util.isSuspendFunction as isSuspendFunctionImpl
 
 class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapperBase(), TypeMappingContext<JvmSignatureWriter> {
-    internal val typeSystem = IrTypeCheckerContext(context.irBuiltIns)
+    internal val typeSystem = IrTypeSystemContextImpl(context.irBuiltIns)
     override val typeContext: TypeSystemCommonBackendContextForTypeMapping = IrTypeCheckerContextForTypeMapping(typeSystem, context)
 
     override fun mapClass(classifier: ClassifierDescriptor): Type =

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt

@@ -229,7 +229,13 @@ internal class CollectionStubMethodLowering(val context: JvmBackendContext) : Cl
     }
 
     private fun createTypeChecker(overrideFun: IrSimpleFunction, parentFun: IrSimpleFunction): AbstractTypeCheckerContext =
-        IrTypeCheckerContextWithAdditionalAxioms(context.irBuiltIns, overrideFun.typeParameters, parentFun.typeParameters)
+        IrTypeCheckerContext(
+            IrTypeSystemContextWithAdditionalAxioms(
+                context.irBuiltIns,
+                overrideFun.typeParameters,
+                parentFun.typeParameters
+            )
+        )
 
     private fun areTypeParametersEquivalent(
         overrideFun: IrSimpleFunction,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/IrOverridingUtil.kt

@@ -425,14 +425,14 @@ class IrOverridingUtil(
         return if (a == null || b == null) true else isVisibilityMoreSpecific(a, b)
     }
 
-    private fun IrTypeCheckerContextWithAdditionalAxioms.isSubtypeOf(a: IrType, b: IrType) =
+    private fun IrTypeCheckerContext.isSubtypeOf(a: IrType, b: IrType) =
         AbstractTypeChecker.isSubtypeOf(this as AbstractTypeCheckerContext, a, b)
 
-    private fun IrTypeCheckerContextWithAdditionalAxioms.equalTypes(a: IrType, b: IrType) =
+    private fun IrTypeCheckerContext.equalTypes(a: IrType, b: IrType) =
         AbstractTypeChecker.equalTypes(this as AbstractTypeCheckerContext, a, b)
 
     private fun createTypeChecker(a: List<IrTypeParameter>, b: List<IrTypeParameter>) =
-        IrTypeCheckerContextWithAdditionalAxioms(irBuiltIns, a, b)
+        IrTypeCheckerContext(IrTypeSystemContextWithAdditionalAxioms(irBuiltIns, a, b))
 
     private fun isReturnTypeMoreSpecific(
         a: IrOverridableMember,
@@ -661,10 +661,12 @@ class IrOverridingUtil(
         }
 
         val typeCheckerContext =
-            IrTypeCheckerContextWithAdditionalAxioms(
-                irBuiltIns,
-                superTypeParameters,
-                subTypeParameters
+            IrTypeCheckerContext(
+                IrTypeSystemContextWithAdditionalAxioms(
+                    irBuiltIns,
+                    superTypeParameters,
+                    subTypeParameters
+                )
             )
 
         /* TODO: check the bounds. See OverridingUtil.areTypeParametersEquivalent()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerContext.kt

@@ -10,7 +10,9 @@ import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
 import org.jetbrains.kotlin.types.model.*
 
-open class IrTypeCheckerContext(override val irBuiltIns: IrBuiltIns) : IrTypeSystemContext, AbstractTypeCheckerContext() {
+open class IrTypeCheckerContext(override val typeSystemContext: IrTypeSystemContext): AbstractTypeCheckerContext() {
+
+    val irBuiltIns: IrBuiltIns get() = typeSystemContext.irBuiltIns
 
     override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy.DoCustomTransform {
         require(type is IrSimpleType)
@@ -30,32 +32,4 @@ open class IrTypeCheckerContext(override val irBuiltIns: IrBuiltIns) : IrTypeSys
 
     override val KotlinTypeMarker.isAllowedTypeVariable: Boolean
         get() = false
-
-    override fun newBaseTypeCheckerContext(
-        errorTypesEqualToAnything: Boolean,
-        stubTypesEqualToAnything: Boolean
-    ): AbstractTypeCheckerContext = IrTypeCheckerContext(irBuiltIns)
-
-    override fun KotlinTypeMarker.isUninferredParameter(): Boolean = false
-    override fun KotlinTypeMarker.withNullability(nullable: Boolean): KotlinTypeMarker {
-        if (this.isSimpleType()) {
-            return this.asSimpleType()!!.withNullability(nullable)
-        } else {
-            error("withNullability for non-simple types is not supported in IR")
-        }
-    }
-
-    override fun captureFromExpression(type: KotlinTypeMarker): KotlinTypeMarker? =
-        error("Captured type is unsupported in IR")
-
-    override fun DefinitelyNotNullTypeMarker.original(): SimpleTypeMarker =
-        error("DefinitelyNotNull type is unsupported in IR")
-
-    override fun KotlinTypeMarker.makeDefinitelyNotNullOrNotNull(): KotlinTypeMarker {
-        error("makeDefinitelyNotNullOrNotNull is not supported in IR")
-    }
-
-    override fun SimpleTypeMarker.makeSimpleTypeDefinitelyNotNullOrNotNull(): SimpleTypeMarker {
-        error("makeSimpleTypeDefinitelyNotNullOrNotNull is not yet supported in IR")
-    }
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerUtils.kt

@@ -9,11 +9,11 @@ import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
 import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
 
-open class IrTypeCheckerContextWithAdditionalAxioms(
+class IrTypeSystemContextWithAdditionalAxioms(
     override val irBuiltIns: IrBuiltIns,
     firstParameters: List<IrTypeParameter>,
     secondParameters: List<IrTypeParameter>
-) : IrTypeCheckerContext(irBuiltIns) {
+) : IrTypeSystemContext {
     init {
         assert(firstParameters.size == secondParameters.size) {
             "different length of type parameter lists: $firstParameters vs $secondParameters"

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.types.model.*
@@ -454,6 +455,39 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon
         val irClass = (this as IrType).classOrNull?.owner
         return irClass != null && (irClass.isInterface || irClass.isAnnotationClass)
     }
+
+
+    override fun newBaseTypeCheckerContext(
+        errorTypesEqualToAnything: Boolean,
+        stubTypesEqualToAnything: Boolean
+    ): AbstractTypeCheckerContext = IrTypeCheckerContext(this)
+
+    override fun KotlinTypeMarker.isUninferredParameter(): Boolean = false
+    override fun KotlinTypeMarker.withNullability(nullable: Boolean): KotlinTypeMarker {
+        if (this.isSimpleType()) {
+            return this.asSimpleType()!!.withNullability(nullable)
+        } else {
+            error("withNullability for non-simple types is not supported in IR")
+        }
+    }
+
+    override fun captureFromExpression(type: KotlinTypeMarker): KotlinTypeMarker? =
+        error("Captured type is unsupported in IR")
+
+    override fun DefinitelyNotNullTypeMarker.original(): SimpleTypeMarker =
+        error("DefinitelyNotNull type is unsupported in IR")
+
+    override fun KotlinTypeMarker.makeDefinitelyNotNullOrNotNull(): KotlinTypeMarker {
+        error("makeDefinitelyNotNullOrNotNull is not supported in IR")
+    }
+
+    override fun SimpleTypeMarker.makeSimpleTypeDefinitelyNotNullOrNotNull(): SimpleTypeMarker {
+        error("makeSimpleTypeDefinitelyNotNullOrNotNull is not yet supported in IR")
+    }
+
+    override fun prepareType(type: KotlinTypeMarker): KotlinTypeMarker {
+        return type
+    }
 }
 
 fun extractTypeParameters(parent: IrDeclarationParent): List<IrTypeParameter> {
@@ -480,3 +514,6 @@ fun extractTypeParameters(parent: IrDeclarationParent): List<IrTypeParameter> {
     }
     return result
 }
+
+
+class IrTypeSystemContextImpl(override val irBuiltIns: IrBuiltIns) : IrTypeSystemContext

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt

@@ -32,7 +32,11 @@ fun IrType.isSubtypeOfClass(superClass: IrClassSymbol): Boolean {
 }
 
 fun IrType.isSubtypeOf(superType: IrType, irBuiltIns: IrBuiltIns): Boolean {
-    return AbstractTypeChecker.isSubtypeOf(IrTypeCheckerContext(irBuiltIns) as AbstractTypeCheckerContext, this, superType)
+    return AbstractTypeChecker.isSubtypeOf(
+        IrTypeCheckerContext(IrTypeSystemContextImpl(irBuiltIns)) as AbstractTypeCheckerContext,
+        this,
+        superType
+    )
 }
 
 fun IrType.isNullable(): Boolean =