From 7fed0c64f0bc607c34c017b6df7e1fecc027ec67 Mon Sep 17 00:00:00 2001
From: Mikhail Glukhikh <mikhail.glukhikh@jetbrains.com>
Date: Thu, 24 Nov 2022 17:33:29 +0100
Subject: [PATCH] EmptyIntersectionTypeChecker: minor refactoring

---
 .../checkers/EmptyIntersectionTypeChecker.kt  | 56 ++++++++++---------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt b/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt
index 0b36e7524e4..960de7e867e 100644
--- a/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt
+++ b/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt
@@ -91,19 +91,7 @@ internal object EmptyIntersectionTypeChecker {
                     return EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.MULTIPLE_CLASSES, firstType, secondType)
                 }
 
-                val firstSuperTypeWithSecondConstructor = AbstractTypeChecker.findCorrespondingSupertypes(
-                    typeCheckerState, firstType.lowerBoundIfFlexible(), secondTypeConstructor
-                ).singleOrNull()
-                val secondSuperTypeByFirstConstructor = AbstractTypeChecker.findCorrespondingSupertypes(
-                    typeCheckerState, secondType.lowerBoundIfFlexible(), firstTypeConstructor
-                ).singleOrNull()
-
                 val atLeastOneInterface = firstTypeConstructor.isInterface() || secondTypeConstructor.isInterface()
-
-                // Two classes can't have a common subtype if neither is a subtype of another
-                if (firstSuperTypeWithSecondConstructor == null && secondSuperTypeByFirstConstructor == null && !atLeastOneInterface)
-                    return EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.MULTIPLE_CLASSES, firstType, secondType)
-
                 if (atLeastOneInterface) {
                     val incompatibleSupertypes = getIncompatibleSuperTypes(firstType, secondType)
                     if (incompatibleSupertypes != null) {
@@ -111,23 +99,37 @@ internal object EmptyIntersectionTypeChecker {
                     }
                 }
 
-                if (firstSuperTypeWithSecondConstructor == null || secondSuperTypeByFirstConstructor == null) {
-                    // don't have incompatible supertypes so can have a common subtype only if all types are interfaces
-                    if (firstTypeConstructor.isFinalClassConstructor() || secondTypeConstructor.isFinalClassConstructor()) {
-                        possibleEmptyIntersectionKind =
-                            EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.SINGLE_FINAL_CLASS, firstType, secondType)
+                val firstSuperTypeWithSecondConstructor = AbstractTypeChecker.findCorrespondingSupertypes(
+                    typeCheckerState, firstType.lowerBoundIfFlexible(), secondTypeConstructor
+                ).singleOrNull()
+                val secondSuperTypeByFirstConstructor = AbstractTypeChecker.findCorrespondingSupertypes(
+                    typeCheckerState, secondType.lowerBoundIfFlexible(), firstTypeConstructor
+                ).singleOrNull()
+
+                when {
+                    firstSuperTypeWithSecondConstructor != null && secondSuperTypeByFirstConstructor != null -> {
+                        val argumentsIntersectionKind =
+                            computeByCheckingTypeArguments(firstSuperTypeWithSecondConstructor, secondSuperTypeByFirstConstructor) ?: continue
+
+                        if (argumentsIntersectionKind.kind.isDefinitelyEmpty())
+                            return argumentsIntersectionKind
+
+                        if (possibleEmptyIntersectionKind == null && argumentsIntersectionKind.kind.isPossiblyEmpty())
+                            possibleEmptyIntersectionKind = argumentsIntersectionKind
+                    }
+                    firstSuperTypeWithSecondConstructor == null && secondSuperTypeByFirstConstructor == null && !atLeastOneInterface -> {
+                        // Two classes can't have a common subtype if neither is a subtype of another
+                        return EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.MULTIPLE_CLASSES, firstType, secondType)
+                    }
+                    else -> {
+                        // don't have incompatible supertypes so can have a common subtype only if all types are interfaces
+                        if (firstTypeConstructor.isFinalClassConstructor() || secondTypeConstructor.isFinalClassConstructor()) {
+                            possibleEmptyIntersectionKind =
+                                EmptyIntersectionTypeInfo(EmptyIntersectionTypeKind.SINGLE_FINAL_CLASS, firstType, secondType)
+                        }
+                        continue
                     }
-                    continue
                 }
-
-                val argumentsIntersectionKind =
-                    computeByCheckingTypeArguments(firstSuperTypeWithSecondConstructor, secondSuperTypeByFirstConstructor) ?: continue
-
-                if (argumentsIntersectionKind.kind.isDefinitelyEmpty())
-                    return argumentsIntersectionKind
-
-                if (possibleEmptyIntersectionKind == null && argumentsIntersectionKind.kind.isPossiblyEmpty())
-                    possibleEmptyIntersectionKind = argumentsIntersectionKind
             }
         }