Rename AbstractTypeCheckerContext to TypeCheckerState

2021-08-25 12:45:24 +03:00
parent 28136d7eb0
commit 8b5548df49
37 changed files with 316 additions and 325 deletions
@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.types.*;
 import org.jetbrains.kotlin.types.checker.*;
-import org.jetbrains.kotlin.types.model.TypeConstructorMarker;
 import org.jetbrains.kotlin.utils.SmartSet;

 import java.util.*;
@@ -309,7 +308,7 @@ public class OverridingUtil {
            return OverrideCompatibilityInfo.conflict("Type parameter number mismatch");
        }

-        Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> typeChecker = createTypeChecker(superTypeParameters, subTypeParameters);
+        Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker = createTypeChecker(superTypeParameters, subTypeParameters);

        for (int i = 0; i < superTypeParameters.size(); i++) {
            if (!areTypeParametersEquivalent(
@@ -385,7 +384,7 @@ public class OverridingUtil {
    }

    @NotNull
-    private Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> createTypeChecker(
+    private Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> createTypeChecker(
            @NotNull List<TypeParameterDescriptor> firstParameters,
            @NotNull List<TypeParameterDescriptor> secondParameters
    ) {
@@ -393,19 +392,19 @@ public class OverridingUtil {
                "Should be the same number of type parameters: " + firstParameters + " vs " + secondParameters;

        NewKotlinTypeCheckerImpl typeChecker = new NewKotlinTypeCheckerImpl(kotlinTypeRefiner, KotlinTypePreparator.Default.INSTANCE);
-        ClassicTypeCheckerContext context = createTypeCheckerContext(firstParameters, secondParameters);
+        ClassicTypeCheckerState context = createTypeCheckerContext(firstParameters, secondParameters);

-        return new Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext>(typeChecker, context);
+        return new Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState>(typeChecker, context);
    }

    @NotNull
-    private ClassicTypeCheckerContext createTypeCheckerContext(
+    private ClassicTypeCheckerState createTypeCheckerContext(
            @NotNull List<TypeParameterDescriptor> firstParameters,
            @NotNull List<TypeParameterDescriptor> secondParameters
    ) {
        if (firstParameters.isEmpty()) {
-            return (ClassicTypeCheckerContext) new OverridingUtilTypeSystemContext(null, equalityAxioms, kotlinTypeRefiner)
-                    .newBaseTypeCheckerContext(true, true);
+            return (ClassicTypeCheckerState) new OverridingUtilTypeSystemContext(null, equalityAxioms, kotlinTypeRefiner)
+                    .newTypeCheckerState(true, true);
        }

        Map<TypeConstructor, TypeConstructor> matchingTypeConstructors = new HashMap<TypeConstructor, TypeConstructor>();
@@ -413,8 +412,8 @@ public class OverridingUtil {
            matchingTypeConstructors.put(firstParameters.get(i).getTypeConstructor(), secondParameters.get(i).getTypeConstructor());
        }

-        return (ClassicTypeCheckerContext) new OverridingUtilTypeSystemContext(matchingTypeConstructors, equalityAxioms, kotlinTypeRefiner)
-                .newBaseTypeCheckerContext(true, true);
+        return (ClassicTypeCheckerState) new OverridingUtilTypeSystemContext(matchingTypeConstructors, equalityAxioms, kotlinTypeRefiner)
+                .newTypeCheckerState(true, true);
    }

    @Nullable
@@ -436,7 +435,7 @@ public class OverridingUtil {
    private boolean areTypesEquivalent(
            @NotNull KotlinType typeInSuper,
            @NotNull KotlinType typeInSub,
-            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> typeChecker
+            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
    ) {
        boolean bothErrors = KotlinTypeKt.isError(typeInSuper) && KotlinTypeKt.isError(typeInSub);
        if (bothErrors) return true;
@@ -447,7 +446,7 @@ public class OverridingUtil {
    private boolean areTypeParametersEquivalent(
            @NotNull TypeParameterDescriptor superTypeParameter,
            @NotNull TypeParameterDescriptor subTypeParameter,
-            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> typeChecker
+            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
    ) {
        List<KotlinType> superBounds = superTypeParameter.getUpperBounds();
        List<KotlinType> subBounds = new ArrayList<KotlinType>(subTypeParameter.getUpperBounds());
@@ -585,7 +584,7 @@ public class OverridingUtil {

        if (!isVisibilityMoreSpecific(a, b)) return false;

-        Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> checker =
+        Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> checker =
                DEFAULT.createTypeChecker(a.getTypeParameters(), b.getTypeParameters());

        if (a instanceof FunctionDescriptor) {
@@ -642,7 +641,7 @@ public class OverridingUtil {
            @NotNull KotlinType aReturnType,
            @NotNull CallableDescriptor b,
            @NotNull KotlinType bReturnType,
-            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerContext> typeChecker
+            @NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
    ) {
        return typeChecker.getFirst().isSubtypeOf(typeChecker.getSecond(), aReturnType.unwrap(), bReturnType.unwrap());
    }
@@ -5,9 +5,9 @@

 package org.jetbrains.kotlin.resolve

-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
+import org.jetbrains.kotlin.types.TypeCheckerState
 import org.jetbrains.kotlin.types.TypeConstructor
-import org.jetbrains.kotlin.types.checker.ClassicTypeCheckerContext
+import org.jetbrains.kotlin.types.checker.ClassicTypeCheckerState
 import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContext
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
@@ -25,11 +25,11 @@ class OverridingUtilTypeSystemContext(
        return super.areEqualTypeConstructors(c1, c2) || areEqualTypeConstructorsByAxioms(c1, c2)
    }

-    override fun newBaseTypeCheckerContext(
+    override fun newTypeCheckerState(
        errorTypesEqualToAnything: Boolean,
        stubTypesEqualToAnything: Boolean
-    ): AbstractTypeCheckerContext {
-        return ClassicTypeCheckerContext(
+    ): TypeCheckerState {
+        return ClassicTypeCheckerState(
            errorTypesEqualToAnything,
            stubTypesEqualToAnything,
            allowedTypeVariable = true,
@@ -45,4 +45,4 @@ class OverridingUtilTypeSystemContext(
        val img2 = matchingTypeConstructors[b]
        return img1 != null && img1 == b || img2 != null && img2 == a
    }
-}
+}
@@ -21,14 +21,14 @@ import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 import org.jetbrains.kotlin.types.refinement.TypeRefinement

-open class ClassicTypeCheckerContext(
+open class ClassicTypeCheckerState(
    val errorTypeEqualsToAnything: Boolean,
    val stubTypeEqualsToAnything: Boolean = true,
    val allowedTypeVariable: Boolean = true,
    val kotlinTypeRefiner: KotlinTypeRefiner = KotlinTypeRefiner.Default,
    val kotlinTypePreparator: KotlinTypePreparator = KotlinTypePreparator.Default,
    override val typeSystemContext: ClassicTypeSystemContext = SimpleClassicTypeSystemContext
-) : AbstractTypeCheckerContext() {
+) : TypeCheckerState() {

    @OptIn(TypeRefinement::class)
    override fun refineType(type: KotlinTypeMarker): KotlinTypeMarker {
@@ -59,7 +59,7 @@ open class ClassicTypeCheckerContext(
            val substitutor = TypeConstructorSubstitution.create(type).buildSubstitutor()

            return object : SupertypesPolicy.DoCustomTransform() {
-                override fun transformType(context: AbstractTypeCheckerContext, type: KotlinTypeMarker): SimpleTypeMarker {
+                override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker {
                    return substitutor.safeSubstitute(
                        type.lowerBoundIfFlexible() as KotlinType,
                        Variance.INVARIANT
@@ -388,11 +388,11 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
    }


-    override fun newBaseTypeCheckerContext(
+    override fun newTypeCheckerState(
        errorTypesEqualToAnything: Boolean,
        stubTypesEqualToAnything: Boolean
-    ): AbstractTypeCheckerContext {
-        return ClassicTypeCheckerContext(errorTypesEqualToAnything, stubTypesEqualToAnything, typeSystemContext = this)
+    ): TypeCheckerState {
+        return ClassicTypeCheckerState(errorTypesEqualToAnything, stubTypesEqualToAnything, typeSystemContext = this)
    }

    override fun nullableNothingType(): SimpleTypeMarker {
@@ -21,14 +21,10 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
 import org.jetbrains.kotlin.resolve.OverridingUtil
 import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
-import org.jetbrains.kotlin.resolve.calls.inference.CapturedTypeConstructorImpl
 import org.jetbrains.kotlin.resolve.constants.IntegerLiteralTypeConstructor
-import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstructor
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.AbstractNullabilityChecker.hasNotNullSupertype
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext.SupertypesPolicy
-import org.jetbrains.kotlin.types.model.CaptureStatus
-import org.jetbrains.kotlin.types.typeUtil.makeNullable
+import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy

 object SimpleClassicTypeSystemContext : ClassicTypeSystemContext

@@ -53,10 +49,10 @@ object StrictEqualityTypeChecker {

 object ErrorTypesAreEqualToAnything : KotlinTypeChecker {
    override fun isSubtypeOf(subtype: KotlinType, supertype: KotlinType): Boolean =
-        NewKotlinTypeChecker.Default.run { ClassicTypeCheckerContext(true).isSubtypeOf(subtype.unwrap(), supertype.unwrap()) }
+        NewKotlinTypeChecker.Default.run { ClassicTypeCheckerState(true).isSubtypeOf(subtype.unwrap(), supertype.unwrap()) }

    override fun equalTypes(a: KotlinType, b: KotlinType): Boolean =
-        NewKotlinTypeChecker.Default.run { ClassicTypeCheckerContext(true).equalTypes(a.unwrap(), b.unwrap()) }
+        NewKotlinTypeChecker.Default.run { ClassicTypeCheckerState(true).equalTypes(a.unwrap(), b.unwrap()) }
 }

 interface NewKotlinTypeChecker : KotlinTypeChecker {
@@ -77,21 +73,21 @@ class NewKotlinTypeCheckerImpl(
    override val overridingUtil: OverridingUtil = OverridingUtil.createWithTypeRefiner(kotlinTypeRefiner)

    override fun isSubtypeOf(subtype: KotlinType, supertype: KotlinType): Boolean =
-        ClassicTypeCheckerContext(
+        ClassicTypeCheckerState(
            true, kotlinTypeRefiner = kotlinTypeRefiner, kotlinTypePreparator = kotlinTypePreparator
        ).isSubtypeOf(subtype.unwrap(), supertype.unwrap()) // todo fix flag errorTypeEqualsToAnything

    override fun equalTypes(a: KotlinType, b: KotlinType): Boolean =
-        ClassicTypeCheckerContext(
+        ClassicTypeCheckerState(
            false, kotlinTypeRefiner = kotlinTypeRefiner, kotlinTypePreparator = kotlinTypePreparator
        ).equalTypes(a.unwrap(), b.unwrap())

-    fun ClassicTypeCheckerContext.equalTypes(a: UnwrappedType, b: UnwrappedType): Boolean {
-        return AbstractTypeChecker.equalTypes(this as AbstractTypeCheckerContext, a, b)
+    fun ClassicTypeCheckerState.equalTypes(a: UnwrappedType, b: UnwrappedType): Boolean {
+        return AbstractTypeChecker.equalTypes(this as TypeCheckerState, a, b)
    }

-    fun ClassicTypeCheckerContext.isSubtypeOf(subType: UnwrappedType, superType: UnwrappedType): Boolean {
-        return AbstractTypeChecker.isSubtypeOf(this as AbstractTypeCheckerContext, subType, superType)
+    fun ClassicTypeCheckerState.isSubtypeOf(subType: UnwrappedType, superType: UnwrappedType): Boolean {
+        return AbstractTypeChecker.isSubtypeOf(this as TypeCheckerState, subType, superType)
    }
 }

@@ -99,18 +95,18 @@ object NullabilityChecker {

    fun isSubtypeOfAny(type: UnwrappedType): Boolean =
        SimpleClassicTypeSystemContext
-            .newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
+            .newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
            .hasNotNullSupertype(type.lowerIfFlexible(), SupertypesPolicy.LowerIfFlexible)
 }

 fun UnwrappedType.hasSupertypeWithGivenTypeConstructor(typeConstructor: TypeConstructor) =
-    ClassicTypeCheckerContext(false).anySupertype(lowerIfFlexible(), {
+    ClassicTypeCheckerState(false).anySupertype(lowerIfFlexible(), {
        require(it is SimpleType)
        it.constructor == typeConstructor
    }, { SupertypesPolicy.LowerIfFlexible })

 fun UnwrappedType.anySuperTypeConstructor(predicate: (TypeConstructor) -> Boolean) =
-    ClassicTypeCheckerContext(false).anySupertype(lowerIfFlexible(), {
+    ClassicTypeCheckerState(false).anySupertype(lowerIfFlexible(), {
        require(it is SimpleType)
        predicate(it.constructor)
    }, { SupertypesPolicy.LowerIfFlexible })