From 3bdd52b64acf20b0c13ec2b2e24c24ffbf439db4 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 6 Sep 2022 11:46:47 +0200 Subject: [PATCH] [FE 1.0] Return to the old type intersection emptiness check This reverts commit 8227c4b603e221ecc85841cfc4a5f1651609ca69. #KT-53656 Fixed --- .../kotlin/fir/types/ConeInferenceContext.kt | 2 - .../kotlin/resolve/DescriptorResolver.java | 4 +- .../calls/checkers/EqualityCallChecker.kt | 4 +- .../KotlinResolutionStatelessCallbacksImpl.kt | 6 +++ .../kotlin/types/CastDiagnosticsUtil.kt | 8 +--- .../kotlin/types/CommonSupertypes.java | 3 +- .../BasicExpressionTypingVisitor.java | 7 +--- .../PatternMatchingTypingVisitor.kt | 3 +- .../calls/components/ExternalComponents.kt | 2 + .../calls/components/ResolutionParts.kt | 5 ++- .../checkers/EmptyIntersectionTypeChecker.kt | 37 ++----------------- .../kotlin/types/EmptyIntersectionTypeKind.kt | 6 +-- .../kotlin/types/model/TypeSystemContext.kt | 2 - .../org/jetbrains/kotlin/types/TypeUtils.kt | 7 ---- .../types/checker/ClassicTypeSystemContext.kt | 17 +-------- 15 files changed, 24 insertions(+), 89 deletions(-) diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt index 42079334048..0533b997d18 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt @@ -426,8 +426,6 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo return withAttributes(attributes.remove(CompilerConeAttributes.Exact)) } - override fun KotlinTypeMarker.canHaveSubtypes(typeChecker: AbstractTypeChecker): Boolean? = null - override fun TypeConstructorMarker.toErrorType(): SimpleTypeMarker { if (this is ErrorTypeConstructor) return createErrorType(reason) if (this is ConeClassLikeLookupTag) return createErrorType("Not found classifier: $classId") diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index b3fda263cfc..76e08ed6d0b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -64,7 +64,6 @@ 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.*; @@ -620,8 +619,7 @@ public class DescriptorResolver { @NotNull TypeParameterDescriptor parameter, @NotNull KtTypeParameter typeParameter ) { - List bounds = parameter.getUpperBounds(); - if (TypeUtilsKt.isEmptyIntersectionTypeCompatible(bounds.toArray(new KotlinTypeMarker[0]))) { + if (KotlinBuiltIns.isNothing(TypeIntersector.getUpperBoundsAsType(parameter))) { trace.report(CONFLICTING_UPPER_BOUNDS.on(typeParameter, parameter)); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/EqualityCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/EqualityCallChecker.kt index 8cb44b68375..d0a26f88264 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/EqualityCallChecker.kt +++ b/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 (isEmptyIntersectionTypeCompatible(leftType, rightType)) { + if (TypeIntersector.isIntersectionEmpty(leftType, rightType)) { val isProperEqualityChecksEnabled = context.languageVersionSettings.supportsFeature(LanguageFeature.ProperEqualityChecksInBuilderInferenceCalls) val shouldReportWarnings = !isProperEqualityChecksEnabled diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt index 7ca1da45f50..ebc4bdce3a4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt @@ -39,6 +39,8 @@ import org.jetbrains.kotlin.resolve.calls.model.SimpleKotlinCallArgument import org.jetbrains.kotlin.resolve.calls.results.SimpleConstraintSystem import org.jetbrains.kotlin.resolve.calls.util.isCallWithSuperReceiver 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 @@ -102,6 +104,10 @@ class KotlinResolutionStatelessCallbacksImpl( return org.jetbrains.kotlin.resolve.calls.inference.isApplicableCallForBuilderInference(descriptor, languageVersionSettings) } + override fun isOldIntersectionIsEmpty(types: Collection): Boolean { + return TypeIntersector.intersectTypes(types) == null + } + override fun createConstraintSystemForOverloadResolution( constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns ): SimpleConstraintSystem = SimpleConstraintSystemImpl(constraintInjector, builtIns, kotlinTypeRefiner, languageVersionSettings) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt index 2483b126bdf..c2926616969 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt @@ -29,10 +29,8 @@ 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 { @@ -225,11 +223,7 @@ object CastDiagnosticsUtil { targetType: KotlinType, shouldCheckForExactType: Boolean ): Boolean { - val types = possibleTypes.map { it.upperIfFlexible() } - - if (isEmptyIntersectionTypeCompatible(*types.toTypedArray())) return false - - val intersectedType = intersectTypes(possibleTypes.map { it.upperIfFlexible() }) + val intersectedType = TypeIntersector.intersectTypes(possibleTypes.map { it.upperIfFlexible() }) ?: return false return if (shouldCheckForExactType) isExactTypeCast(intersectedType, targetType) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java b/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java index b0d4c1f2fca..20bd05be0ec 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java @@ -13,7 +13,6 @@ 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; @@ -345,7 +344,7 @@ public class CommonSupertypes { } if (ins != null) { assert !ins.isEmpty() : "In projections is empty for parameter " + parameterDescriptor + ", type projections " + typeProjections; - KotlinType intersection = IntersectionTypeKt.intersectWrappedTypes(ins); + KotlinType intersection = TypeIntersector.intersectTypes(ins); if (intersection == null) { return TypeUtils.makeStarProjection(parameterDescriptor); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java index 34c4e7c03df..a0e2ea0ce4c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java @@ -1147,12 +1147,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { boolean isBuilderInferenceContext = context.inferenceSession instanceof BuilderInferenceSession; - if ( - leftType != null && - rightType != null && - !TypeUtilsKt.isEmptyIntersectionTypeCompatible(leftType, rightType) && - isBuilderInferenceContext - ) { + if (leftType != null && rightType != null && !TypeIntersector.isIntersectionEmpty(leftType, rightType) && isBuilderInferenceContext) { context.trace.record(MARKED_EQUALIY_CALL_PROPER_IN_BUILDER_INFERENCE, expression); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt index 7b9036ab957..5be3005aa66 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt @@ -46,7 +46,6 @@ 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) { @@ -701,7 +700,7 @@ class PatternMatchingTypingVisitor internal constructor(facade: ExpressionTyping reportErrorOn: KtElement ): Boolean { // TODO : Take smart casts into account? - if (isEmptyIntersectionTypeCompatible(type, subjectType)) { + if (TypeIntersector.isIntersectionEmpty(type, subjectType)) { context.trace.report(INCOMPATIBLE_TYPES.on(reportErrorOn, type, subjectType)) return false } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt index a261b82479e..7b8d4160060 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt @@ -48,6 +48,8 @@ interface KotlinResolutionStatelessCallbacks { fun isBuilderInferenceCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean fun isApplicableCallForBuilderInference(descriptor: CallableDescriptor, languageVersionSettings: LanguageVersionSettings): Boolean + fun isOldIntersectionIsEmpty(types: Collection): Boolean + fun createConstraintSystemForOverloadResolution( constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns ): SimpleConstraintSystem diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt index 36eff2e0bf3..37cb4f2f75f 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.types.error.ErrorUtils import org.jetbrains.kotlin.types.model.* import org.jetbrains.kotlin.types.typeUtil.* import org.jetbrains.kotlin.utils.SmartList +import org.jetbrains.kotlin.utils.addToStdlib.cast import org.jetbrains.kotlin.utils.addToStdlib.compactIfPossible import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -900,8 +901,8 @@ internal object CheckIncompatibleTypeVariableUpperBounds : ResolutionPart() { * Check if the candidate was already discriminated by `CompatibilityOfTypeVariableAsIntersectionTypePart` resolution part * If it's true we shouldn't mark the candidate with warning, but should mark with error, to repeat the existing proper behaviour */ - private fun wasPreviouslyDiscriminated(upperTypes: List) = - isEmptyIntersectionTypeCompatible(*upperTypes.toTypedArray()) + private fun ResolutionCandidate.wasPreviouslyDiscriminated(upperTypes: List) = + callComponents.statelessCallbacks.isOldIntersectionIsEmpty(upperTypes.cast()) override fun ResolutionCandidate.process(workIndex: Int) = with(getSystem().asConstraintSystemCompleterContext()) { val constraintSystem = getSystem() 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 940f519e575..326fd9bcdd4 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 @@ -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, - compatibilityModeEnabled: Boolean = false + types: Collection ): 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) \ No newline at end of file diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/EmptyIntersectionTypeKind.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/EmptyIntersectionTypeKind.kt index 52a71eeb2f5..6671e650a94 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/EmptyIntersectionTypeKind.kt +++ b/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 = diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt index 0604d4e1349..6123013605c 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/model/TypeSystemContext.kt +++ b/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): SimpleTypeMarker fun SimpleTypeMarker.replaceArguments(replacement: (TypeArgumentMarker) -> TypeArgumentMarker): SimpleTypeMarker diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt index dc6dc7df1a5..0d66bdb0193 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt +++ b/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 diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt b/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt index 0ff52d47a78..28997a49e70 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt +++ b/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)