[FE 1.0] Return to the old type intersection emptiness check

This reverts commit 8227c4b603.
#KT-53656 Fixed

core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt

@@ -11,11 +11,10 @@ import org.jetbrains.kotlin.types.isDefinitelyEmpty
 import org.jetbrains.kotlin.types.isPossiblyEmpty
 import org.jetbrains.kotlin.types.model.*
 
-object EmptyIntersectionTypeChecker {
+internal object EmptyIntersectionTypeChecker {
     fun computeEmptyIntersectionEmptiness(
         context: TypeSystemInferenceExtensionContext,
-        types: Collection<KotlinTypeMarker>,
-        compatibilityModeEnabled: Boolean = false
+        types: Collection<KotlinTypeMarker>
     ): EmptyIntersectionTypeInfo? = with(context) {
         if (types.isEmpty()) return null
 
@@ -35,11 +34,6 @@ object EmptyIntersectionTypeChecker {
 
                 if (!mayCauseEmptyIntersection(secondType)) continue
 
-                if (compatibilityModeEnabled) {
-                    val compatibleKind = computeEmptyIntersectionEmptinessCompatible(firstType, secondType)
-                    if (compatibleKind != null) return compatibleKind else continue
-                }
-
                 val secondSubstitutedType = secondType.eraseContainingTypeParameters()
 
                 if (!mayCauseEmptyIntersection(secondSubstitutedType) && !mayCauseEmptyIntersection(firstSubstitutedType)) continue
@@ -292,31 +286,6 @@ object EmptyIntersectionTypeChecker {
         val type = argument.getType()
         return if (type is CapturedTypeMarker) type.typeConstructorProjection() else argument
     }
-
-    private fun TypeSystemInferenceExtensionContext.computeEmptyIntersectionEmptinessCompatible(
-        firstType: KotlinTypeMarker,
-        secondType: KotlinTypeMarker
-    ): EmptyIntersectionTypeInfo? {
-        @Suppress("NAME_SHADOWING")
-        val firstType = firstType.withNullability(false)
-
-        @Suppress("NAME_SHADOWING")
-        val secondType = secondType.withNullability(false)
-
-        val firstErasedType by lazy { firstType.eraseContainingTypeParameters() }
-        val secondErasedType by lazy { secondType.eraseContainingTypeParameters() }
-
-        if (AbstractTypeChecker.areRelatedBySubtyping(this, firstErasedType, secondErasedType))
-            return null
-
-        val canBothHaveSubtypes = firstType.withNullability(false).canHaveSubtypes(AbstractTypeChecker) == true
-                && secondType.withNullability(false).canHaveSubtypes(AbstractTypeChecker) == true
-
-        if (canBothHaveSubtypes)
-            return null
-
-        return EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.COMPATIBLE, firstErasedType, secondErasedType)
-    }
 }
 
-class EmptyIntersectionTypeInfo(val kind: EmptyIntersectionTypeKind, vararg val casingTypes: KotlinTypeMarker)
+class EmptyIntersectionTypeInfo(val kind: EmptyIntersectionTypeKind, vararg val casingTypes: KotlinTypeMarker)

core/compiler.common/src/org/jetbrains/kotlin/types/EmptyIntersectionTypeKind.kt

@@ -9,11 +9,7 @@ enum class EmptyIntersectionTypeKind(val description: String) {
     MULTIPLE_CLASSES("multiple incompatible classes"),
     INCOMPATIBLE_SUPERTYPES("incompatible supertypes"),
     INCOMPATIBLE_TYPE_ARGUMENTS("incompatible type arguments"),
-    SINGLE_FINAL_CLASS("final class and interface"),
-
-    // This kind corresponds to migrated logic from old TypeIntersector
-    // Now it's used for determining types compatibility for is/as/equality checks
-    COMPATIBLE("")
+    SINGLE_FINAL_CLASS("final class and interface")
 }
 
 fun EmptyIntersectionTypeKind.isDefinitelyEmpty(): Boolean =

core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt

@@ -179,8 +179,6 @@ interface TypeSystemInferenceExtensionContext : TypeSystemContext, TypeSystemBui
     fun KotlinTypeMarker.removeAnnotations(): KotlinTypeMarker
     fun KotlinTypeMarker.removeExactAnnotation(): KotlinTypeMarker
 
-    fun KotlinTypeMarker.canHaveSubtypes(typeChecker: AbstractTypeChecker): Boolean?
-
     fun SimpleTypeMarker.replaceArguments(newArguments: List<TypeArgumentMarker>): SimpleTypeMarker
     fun SimpleTypeMarker.replaceArguments(replacement: (TypeArgumentMarker) -> TypeArgumentMarker): SimpleTypeMarker
 

core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.inference.isCaptured
-import org.jetbrains.kotlin.resolve.checkers.EmptyIntersectionTypeChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.*
@@ -31,7 +30,6 @@ import org.jetbrains.kotlin.types.model.TypeArgumentMarker
 import org.jetbrains.kotlin.types.model.TypeVariableTypeConstructorMarker
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.kotlin.types.error.ErrorUtils
-import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 
@@ -397,8 +395,3 @@ fun isUnresolvedType(type: KotlinType): Boolean {
     }
     return type is ErrorType && type.kind.isUnresolved
 }
-
-fun isEmptyIntersectionTypeCompatible(vararg types: KotlinTypeMarker): Boolean =
-    EmptyIntersectionTypeChecker.computeEmptyIntersectionEmptiness(
-        SimpleClassicTypeSystemContext, types.toList(), compatibilityModeEnabled = true
-    )?.kind == EmptyIntersectionTypeKind.COMPATIBLE

core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt

@@ -425,10 +425,11 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
         return when (this) {
             is SimpleTypeMarker -> this.withNullability(nullable)
             is FlexibleTypeMarker -> createFlexibleType(lowerBound().withNullability(nullable), upperBound().withNullability(nullable))
-            else -> asSimpleType()?.withNullability(nullable) ?: error("Unwrapped type should be simple")
+            else -> error("sealed")
         }
     }
 
+
     override fun newTypeCheckerState(
         errorTypesEqualToAnything: Boolean,
         stubTypesEqualToAnything: Boolean
@@ -477,20 +478,6 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
         return this.replaceAnnotations(Annotations.create(annotationsWithoutExact))
     }
 
-    override fun KotlinTypeMarker.canHaveSubtypes(typeChecker: AbstractTypeChecker): Boolean? {
-        require(this is KotlinType, this::errorMessage)
-
-        val kotlinTypeChecker = object : KotlinTypeChecker {
-            override fun isSubtypeOf(subtype: KotlinType, supertype: KotlinType): Boolean =
-                typeChecker.isSubtypeOf(this@ClassicTypeSystemContext, subtype, supertype)
-
-            override fun equalTypes(a: KotlinType, b: KotlinType): Boolean =
-                typeChecker.equalTypes(this@ClassicTypeSystemContext, a, b)
-        }
-
-        return TypeUtils.canHaveSubtypes(kotlinTypeChecker, this)
-    }
-
     override fun KotlinTypeMarker.hasExactAnnotation(): Boolean {
         require(this is UnwrappedType, this::errorMessage)
         return hasExactInternal(this)