[FE 1.0] Use the new type intersection emptiness check

Also introduced compatibility mode to preserve compatibility for is/as/equality checks

^KT-29316 Related

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -64,6 +64,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker;
 import org.jetbrains.kotlin.types.error.ErrorTypeKind;
 import org.jetbrains.kotlin.types.error.ErrorUtils;
 import org.jetbrains.kotlin.types.expressions.*;
+import org.jetbrains.kotlin.types.model.KotlinTypeMarker;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 
 import java.util.*;
@@ -619,7 +620,8 @@ public class DescriptorResolver {
             @NotNull TypeParameterDescriptor parameter,
             @NotNull KtTypeParameter typeParameter
     ) {
-        if (KotlinBuiltIns.isNothing(TypeIntersector.getUpperBoundsAsType(parameter))) {
+        List<KotlinType> bounds = parameter.getUpperBounds();
+        if (TypeUtilsKt.isEmptyIntersectionTypeCompatible(bounds.toArray(new KotlinTypeMarker[0]))) {
             trace.report(CONFLICTING_UPPER_BOUNDS.on(typeParameter, parameter));
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/EqualityCallChecker.kt

@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceSession
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeIntersector
 import org.jetbrains.kotlin.types.checkEnumsForCompatibility
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker.checkSenselessComparisonWithNull
 import org.jetbrains.kotlin.types.typeUtil.builtIns
+import org.jetbrains.kotlin.types.typeUtil.isEmptyIntersectionTypeCompatible
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 object EqualityCallChecker : CallChecker {
@@ -90,7 +90,7 @@ object EqualityCallChecker : CallChecker {
         val leftType = context.trace.getType(left) ?: return
         val rightType = context.trace.getType(right) ?: return
 
-        if (TypeIntersector.isIntersectionEmpty(leftType, rightType)) {
+        if (isEmptyIntersectionTypeCompatible(leftType, rightType)) {
             val isProperEqualityChecksEnabled =
                 context.languageVersionSettings.supportsFeature(LanguageFeature.ProperEqualityChecksInBuilderInferenceCalls)
             val shouldReportWarnings = !isProperEqualityChecksEnabled

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt

@@ -39,8 +39,6 @@ import org.jetbrains.kotlin.resolve.calls.model.KotlinCallArgument
 import org.jetbrains.kotlin.resolve.calls.model.SimpleKotlinCallArgument
 import org.jetbrains.kotlin.resolve.calls.results.SimpleConstraintSystem
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeIntersector
 import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
@@ -104,10 +102,6 @@ class KotlinResolutionStatelessCallbacksImpl(
         return org.jetbrains.kotlin.resolve.calls.inference.isApplicableCallForBuilderInference(descriptor, languageVersionSettings)
     }
 
-    override fun isOldIntersectionIsEmpty(types: Collection<KotlinType>): Boolean {
-        return TypeIntersector.intersectTypes(types) == null
-    }
-
     override fun createConstraintSystemForOverloadResolution(
         constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns
     ): SimpleConstraintSystem {

compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt

@@ -29,8 +29,10 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.checker.TypeCheckingProcedure
+import org.jetbrains.kotlin.types.checker.intersectTypes
 import org.jetbrains.kotlin.types.expressions.DataFlowAnalyzer
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
+import org.jetbrains.kotlin.types.typeUtil.isEmptyIntersectionTypeCompatible
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 
 object CastDiagnosticsUtil {
@@ -223,7 +225,11 @@ object CastDiagnosticsUtil {
         targetType: KotlinType,
         shouldCheckForExactType: Boolean
     ): Boolean {
-        val intersectedType = TypeIntersector.intersectTypes(possibleTypes.map { it.upperIfFlexible() }) ?: return false
+        val types = possibleTypes.map { it.upperIfFlexible() }
+
+        if (isEmptyIntersectionTypeCompatible(*types.toTypedArray())) return false
+
+        val intersectedType = intersectTypes(possibleTypes.map { it.upperIfFlexible() })
 
         return if (shouldCheckForExactType)
             isExactTypeCast(intersectedType, targetType)

compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
+import org.jetbrains.kotlin.types.checker.IntersectionTypeKt;
 import org.jetbrains.kotlin.types.error.ErrorScopeKind;
 import org.jetbrains.kotlin.types.error.ErrorTypeKind;
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
@@ -344,7 +345,7 @@ public class CommonSupertypes {
         }
         if (ins != null) {
             assert !ins.isEmpty() : "In projections is empty for parameter " + parameterDescriptor + ", type projections " + typeProjections;
-            KotlinType intersection = TypeIntersector.intersectTypes(ins);
+            KotlinType intersection = IntersectionTypeKt.intersectWrappedTypes(ins);
             if (intersection == null) {
                 return TypeUtils.makeStarProjection(parameterDescriptor);
             }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -78,6 +78,7 @@ import org.jetbrains.kotlin.types.expressions.unqualifiedSuper.UnqualifiedSuperK
 import org.jetbrains.kotlin.types.typeUtil.TypeUtilsKt;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -1147,7 +1148,12 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         boolean isBuilderInferenceContext = context.inferenceSession instanceof BuilderInferenceSession;
 
-        if (leftType != null && rightType != null && !TypeIntersector.isIntersectionEmpty(leftType, rightType) && isBuilderInferenceContext) {
+        if (
+                leftType != null &&
+                rightType != null &&
+                !TypeUtilsKt.isEmptyIntersectionTypeCompatible(leftType, rightType) &&
+                isBuilderInferenceContext
+        ) {
             context.trace.record(MARKED_EQUALIY_CALL_PROPER_IN_BUILDER_INFERENCE, expression);
         }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt

@@ -46,6 +46,7 @@ import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo
 import org.jetbrains.kotlin.types.expressions.typeInfoFactory.noTypeInfo
 import org.jetbrains.kotlin.types.typeUtil.containsError
 import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
+import org.jetbrains.kotlin.types.typeUtil.isEmptyIntersectionTypeCompatible
 import java.util.*
 
 class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTypingInternals) : ExpressionTypingVisitor(facade) {
@@ -700,7 +701,7 @@ class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTyping
         reportErrorOn: KtElement
     ): Boolean {
         // TODO : Take smart casts into account?
-        if (TypeIntersector.isIntersectionEmpty(type, subjectType)) {
+        if (isEmptyIntersectionTypeCompatible(type, subjectType)) {
             context.trace.report(INCOMPATIBLE_TYPES.on(reportErrorOn, type, subjectType))
             return false
         }