From ec97dab6cd4b20597d673afdfe63351d4324f57c Mon Sep 17 00:00:00 2001 From: "Denis.Zharkov" Date: Wed, 22 Sep 2021 16:40:30 +0300 Subject: [PATCH] Simplify OverridingUtil Do not use NewKotlinTypeCheckerImpl --- .../kotlin/types/AbstractTypeChecker.kt | 1 + .../kotlin/resolve/OverridingUtil.java | 52 ++++++++----------- 2 files changed, 22 insertions(+), 31 deletions(-) diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt index 42f8cb80263..54a41f0b23a 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt @@ -202,6 +202,7 @@ object AbstractTypeChecker { return equalTypes(context.newTypeCheckerState(false, stubTypesEqualToAnything), a, b) } + @JvmOverloads fun isSubtypeOf( state: TypeCheckerState, subType: KotlinTypeMarker, diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java index e6f80286003..0cbe834f483 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java @@ -35,7 +35,6 @@ import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.checker.KotlinTypeChecker; import org.jetbrains.kotlin.types.checker.KotlinTypePreparator; import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner; -import org.jetbrains.kotlin.types.checker.NewKotlinTypeCheckerImpl; import org.jetbrains.kotlin.utils.SmartSet; import java.util.*; @@ -311,13 +310,14 @@ public class OverridingUtil { return OverrideCompatibilityInfo.conflict("Type parameter number mismatch"); } - Pair typeChecker = createTypeChecker(superTypeParameters, subTypeParameters); + + TypeCheckerState typeCheckerState = createTypeCheckerState(superTypeParameters, subTypeParameters); for (int i = 0; i < superTypeParameters.size(); i++) { if (!areTypeParametersEquivalent( superTypeParameters.get(i), subTypeParameters.get(i), - typeChecker + typeCheckerState )) { return OverrideCompatibilityInfo.incompatible("Type parameter bounds mismatch"); } @@ -327,7 +327,7 @@ public class OverridingUtil { if (!areTypesEquivalent( superValueParameters.get(i), subValueParameters.get(i), - typeChecker) + typeCheckerState) ) { return OverrideCompatibilityInfo.incompatible("Value parameter type mismatch"); } @@ -345,8 +345,8 @@ public class OverridingUtil { if (superReturnType != null && subReturnType != null) { boolean bothErrors = KotlinTypeKt.isError(subReturnType) && KotlinTypeKt.isError(superReturnType); if (!bothErrors && - !typeChecker.getFirst().isSubtypeOf( - typeChecker.getSecond(), + !AbstractTypeChecker.INSTANCE.isSubtypeOf( + typeCheckerState, subReturnType.unwrap(), superReturnType.unwrap() ) @@ -387,24 +387,13 @@ public class OverridingUtil { } @NotNull - private Pair createTypeChecker( + private TypeCheckerState createTypeCheckerState( @NotNull List firstParameters, @NotNull List secondParameters ) { assert firstParameters.size() == secondParameters.size() : "Should be the same number of type parameters: " + firstParameters + " vs " + secondParameters; - NewKotlinTypeCheckerImpl typeChecker = new NewKotlinTypeCheckerImpl(kotlinTypeRefiner, KotlinTypePreparator.Default.INSTANCE); - TypeCheckerState state = createTypeCheckerState(firstParameters, secondParameters); - - return new Pair(typeChecker, state); - } - - @NotNull - private TypeCheckerState createTypeCheckerState( - @NotNull List firstParameters, - @NotNull List secondParameters - ) { if (firstParameters.isEmpty()) { return new OverridingUtilTypeSystemContext(null, equalityAxioms, kotlinTypeRefiner) .newTypeCheckerState(true, true); @@ -435,21 +424,21 @@ public class OverridingUtil { return null; } - private boolean areTypesEquivalent( + private static boolean areTypesEquivalent( @NotNull KotlinType typeInSuper, @NotNull KotlinType typeInSub, - @NotNull Pair typeChecker + @NotNull TypeCheckerState typeCheckerState ) { boolean bothErrors = KotlinTypeKt.isError(typeInSuper) && KotlinTypeKt.isError(typeInSub); if (bothErrors) return true; - return typeChecker.getFirst().equalTypes(typeChecker.getSecond(), typeInSuper.unwrap(), typeInSub.unwrap()); + return AbstractTypeChecker.INSTANCE.equalTypes(typeCheckerState, typeInSuper.unwrap(), typeInSub.unwrap()); } // See JLS 8, 8.4.4 Generic Methods - private boolean areTypeParametersEquivalent( + private static boolean areTypeParametersEquivalent( @NotNull TypeParameterDescriptor superTypeParameter, @NotNull TypeParameterDescriptor subTypeParameter, - @NotNull Pair typeChecker + @NotNull TypeCheckerState typeCheckerState ) { List superBounds = superTypeParameter.getUpperBounds(); List subBounds = new ArrayList(subTypeParameter.getUpperBounds()); @@ -460,7 +449,7 @@ public class OverridingUtil { ListIterator it = subBounds.listIterator(); while (it.hasNext()) { KotlinType subBound = it.next(); - if (areTypesEquivalent(superBound, subBound, typeChecker)) { + if (areTypesEquivalent(superBound, subBound, typeCheckerState)) { it.remove(); continue outer; } @@ -587,13 +576,14 @@ public class OverridingUtil { if (!isVisibilityMoreSpecific(a, b)) return false; - Pair checker = - DEFAULT.createTypeChecker(a.getTypeParameters(), b.getTypeParameters()); + + TypeCheckerState checkerState = + DEFAULT.createTypeCheckerState(a.getTypeParameters(), b.getTypeParameters()); if (a instanceof FunctionDescriptor) { assert b instanceof FunctionDescriptor : "b is " + b.getClass(); - return isReturnTypeMoreSpecific(a, aReturnType, b, bReturnType, checker); + return isReturnTypeMoreSpecific(a, aReturnType, b, bReturnType, checkerState); } if (a instanceof PropertyDescriptor) { assert b instanceof PropertyDescriptor : "b is " + b.getClass(); @@ -605,11 +595,11 @@ public class OverridingUtil { if (pa.isVar() && pb.isVar()) { // TODO(dsavvinov): using DEFAULT here looks suspicious - return checker.getFirst().equalTypes(checker.getSecond(), aReturnType.unwrap(), bReturnType.unwrap()); + return AbstractTypeChecker.INSTANCE.equalTypes(checkerState, aReturnType.unwrap(), bReturnType.unwrap()); } else { // both vals or var vs val: val can't be more specific then var - return !(!pa.isVar() && pb.isVar()) && isReturnTypeMoreSpecific(a, aReturnType, b, bReturnType, checker); + return !(!pa.isVar() && pb.isVar()) && isReturnTypeMoreSpecific(a, aReturnType, b, bReturnType, checkerState); } } throw new IllegalArgumentException("Unexpected callable: " + a.getClass()); @@ -644,9 +634,9 @@ public class OverridingUtil { @NotNull KotlinType aReturnType, @NotNull CallableDescriptor b, @NotNull KotlinType bReturnType, - @NotNull Pair typeChecker + @NotNull TypeCheckerState typeCheckerState ) { - return typeChecker.getFirst().isSubtypeOf(typeChecker.getSecond(), aReturnType.unwrap(), bReturnType.unwrap()); + return AbstractTypeChecker.INSTANCE.isSubtypeOf(typeCheckerState, aReturnType.unwrap(), bReturnType.unwrap()); } @NotNull