Remove all type system-specific inheritors of TypeCheckerState

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

@@ -229,7 +229,7 @@ internal class CollectionStubMethodLowering(val context: JvmBackendContext) : Cl
     }
 
     private fun createTypeCheckerState(overrideFun: IrSimpleFunction, parentFun: IrSimpleFunction): TypeCheckerState =
-        IrTypeCheckerState(
+        createIrTypeCheckerState(
             IrTypeSystemContextWithAdditionalAxioms(
                 context.typeSystem,
                 overrideFun.typeParameters,

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

@@ -438,14 +438,14 @@ class IrOverridingUtil(
         return if (a == null || b == null) true else isVisibilityMoreSpecific(a, b)
     }
 
-    private fun IrTypeCheckerState.isSubtypeOf(a: IrType, b: IrType) =
-        AbstractTypeChecker.isSubtypeOf(this as TypeCheckerState, a, b)
+    private fun TypeCheckerState.isSubtypeOf(a: IrType, b: IrType) =
+        AbstractTypeChecker.isSubtypeOf(this, a, b)
 
-    private fun IrTypeCheckerState.equalTypes(a: IrType, b: IrType) =
-        AbstractTypeChecker.equalTypes(this as TypeCheckerState, a, b)
+    private fun TypeCheckerState.equalTypes(a: IrType, b: IrType) =
+        AbstractTypeChecker.equalTypes(this, a, b)
 
-    private fun createTypeCheckerState(a: List<IrTypeParameter>, b: List<IrTypeParameter>) =
-        IrTypeCheckerState(IrTypeSystemContextWithAdditionalAxioms(typeSystem, a, b))
+    private fun createTypeCheckerState(a: List<IrTypeParameter>, b: List<IrTypeParameter>): TypeCheckerState =
+        createIrTypeCheckerState(IrTypeSystemContextWithAdditionalAxioms(typeSystem, a, b))
 
     private fun isReturnTypeMoreSpecific(
         a: IrOverridableMember,
@@ -453,8 +453,8 @@ class IrOverridingUtil(
         b: IrOverridableMember,
         bReturnType: IrType
     ): Boolean {
-        val typeCheckerContext = createTypeCheckerState(a.typeParameters, b.typeParameters)
-        return typeCheckerContext.isSubtypeOf(aReturnType, bReturnType)
+        val typeCheckerState = createTypeCheckerState(a.typeParameters, b.typeParameters)
+        return typeCheckerState.isSubtypeOf(aReturnType, bReturnType)
     }
 
     private fun isMoreSpecific(
@@ -674,7 +674,7 @@ class IrOverridingUtil(
         }
 
         val typeCheckerState =
-            IrTypeCheckerState(
+            createIrTypeCheckerState(
                 IrTypeSystemContextWithAdditionalAxioms(
                     typeSystem,
                     superTypeParameters,
@@ -697,7 +697,7 @@ class IrOverridingUtil(
 
         superValueParameters.forEachIndexed { index, parameter ->
             if (!AbstractTypeChecker.equalTypes(
-                    typeCheckerState as TypeCheckerState,
+                    typeCheckerState,
                     subValueParameters[index].type,
                     parameter.type
                 )
@@ -710,7 +710,7 @@ class IrOverridingUtil(
 
         if (checkReturnType) {
             if (!AbstractTypeChecker.isSubtypeOf(
-                    typeCheckerState as TypeCheckerState,
+                    typeCheckerState,
                     subMember.returnType,
                     superMember.returnType
                 )

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

@@ -5,26 +5,17 @@
 
 package org.jetbrains.kotlin.ir.types
 
-import org.jetbrains.kotlin.ir.IrBuiltIns
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.types.AbstractTypePreparator
 import org.jetbrains.kotlin.types.AbstractTypeRefiner
 import org.jetbrains.kotlin.types.TypeCheckerState
-import org.jetbrains.kotlin.types.model.KotlinTypeMarker
-import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 
-open class IrTypeCheckerState(override val typeSystemContext: IrTypeSystemContext): TypeCheckerState() {
-
-    override val kotlinTypePreparator: AbstractTypePreparator
-        get() = AbstractTypePreparator.Default
-    override val kotlinTypeRefiner: AbstractTypeRefiner
-        get() = AbstractTypeRefiner.Default
-
-    val irBuiltIns: IrBuiltIns get() = typeSystemContext.irBuiltIns
-
-    override val isErrorTypeEqualsToAnything get() = false
-    override val isStubTypeEqualsToAnything get() = false
-
-    override val allowedTypeVariable: Boolean
-        get() = false
+fun createIrTypeCheckerState(typeSystemContext: IrTypeSystemContext): TypeCheckerState {
+    return TypeCheckerState(
+        isErrorTypeEqualsToAnything = false,
+        isStubTypeEqualsToAnything = false,
+        allowedTypeVariable = false,
+        typeSystemContext = typeSystemContext,
+        kotlinTypePreparator = AbstractTypePreparator.Default,
+        kotlinTypeRefiner = AbstractTypeRefiner.Default
+    )
 }

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

@@ -504,7 +504,7 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon
     override fun newTypeCheckerState(
         errorTypesEqualToAnything: Boolean,
         stubTypesEqualToAnything: Boolean
-    ): TypeCheckerState = IrTypeCheckerState(this)
+    ): TypeCheckerState = createIrTypeCheckerState(this)
 
     override fun KotlinTypeMarker.isUninferredParameter(): Boolean = false
     override fun KotlinTypeMarker.withNullability(nullable: Boolean): KotlinTypeMarker {

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

@@ -30,7 +30,7 @@ fun IrType.isSubtypeOfClass(superClass: IrClassSymbol): Boolean =
     this is IrSimpleType && classifier.isSubtypeOfClass(superClass)
 
 fun IrType.isSubtypeOf(superType: IrType, typeSystem: IrTypeSystemContext): Boolean =
-    AbstractTypeChecker.isSubtypeOf(IrTypeCheckerState(typeSystem), this, superType)
+    AbstractTypeChecker.isSubtypeOf(createIrTypeCheckerState(typeSystem), this, superType)
 
 fun IrType.isNullable(): Boolean =
     when (this) {