azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
This reverts commit 8227c4b603.
#KT-53656 Fixed
This commit is contained in:
Mikhail Glukhikh
2022-09-06 11:46:47 +02:00
committed by Space
parent 5c09d7838d
commit 3bdd52b64a
15 changed files with 24 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeInferenceContext.kt
-2
View File
@@ -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")
compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+1 -3
View File
@@ -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<KotlinType> 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));
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/EqualityCallChecker.kt
+2 -2
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinResolutionStatelessCallbacksImpl.kt
+6
View File
@@ -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<KotlinType>): Boolean {
return TypeIntersector.intersectTypes(types) == null
}
override fun createConstraintSystemForOverloadResolution(
constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns
): SimpleConstraintSystem = SimpleConstraintSystemImpl(constraintInjector, builtIns, kotlinTypeRefiner, languageVersionSettings)
compiler/frontend/src/org/jetbrains/kotlin/types/CastDiagnosticsUtil.kt
+1 -7
View File
@@ -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)
compiler/frontend/src/org/jetbrains/kotlin/types/CommonSupertypes.java
+1 -2
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java
+1 -6
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PatternMatchingTypingVisitor.kt
+1 -2
View File
@@ -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
}
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ExternalComponents.kt
+2
View File
@@ -48,6 +48,8 @@ interface KotlinResolutionStatelessCallbacks {
fun isBuilderInferenceCall(argument: KotlinCallArgument, parameter: ValueParameterDescriptor): Boolean
fun isApplicableCallForBuilderInference(descriptor: CallableDescriptor, languageVersionSettings: LanguageVersionSettings): Boolean
fun isOldIntersectionIsEmpty(types: Collection<KotlinType>): Boolean
fun createConstraintSystemForOverloadResolution(
constraintInjector: ConstraintInjector, builtIns: KotlinBuiltIns
): SimpleConstraintSystem
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt
+3 -2
View File
@@ -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<KotlinTypeMarker>) =
isEmptyIntersectionTypeCompatible(*upperTypes.toTypedArray())
private fun ResolutionCandidate.wasPreviouslyDiscriminated(upperTypes: List<KotlinTypeMarker>) =
callComponents.statelessCallbacks.isOldIntersectionIsEmpty(upperTypes.cast())
override fun ResolutionCandidate.process(workIndex: Int) = with(getSystem().asConstraintSystemCompleterContext()) {
val constraintSystem = getSystem()
core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/EmptyIntersectionTypeChecker.kt
+3 -34
View File
@@ -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
+1 -5
View File
@@ -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
-2
View File
@@ -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
-7
View File
@@ -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
+2 -15
View File
@@ -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)