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
@@ -537,7 +537,7 @@ fun FirExpression.isFunctional(
            val returnTypeCompatible =
                expectedReturnType is ConeTypeParameterType ||
                        AbstractTypeChecker.isSubtypeOf(
-                            session.inferenceComponents.ctx.newBaseTypeCheckerContext(
+                            session.inferenceComponents.ctx.newTypeCheckerState(
                                errorTypesEqualToAnything = false,
                                stubTypesEqualToAnything = true
                            ),
@@ -557,7 +557,7 @@ fun FirExpression.isFunctional(
                val expectedParameterType = expectedParameter.lowerBoundIfFlexible()
                expectedParameterType is ConeTypeParameterType ||
                        AbstractTypeChecker.isSubtypeOf(
-                            session.inferenceComponents.ctx.newBaseTypeCheckerContext(
+                            session.inferenceComponents.ctx.newTypeCheckerState(
                                errorTypesEqualToAnything = false,
                                stubTypesEqualToAnything = true
                            ),
@@ -649,7 +649,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
        if (originalType !is ConeClassLikeType) return type
        val baseFirClass = originalType.lookupTag.toSymbol(session)?.fir ?: return type
        val isSubtype = AbstractTypeChecker.isSubtypeOfClass(
-            session.typeContext.newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true),
+            session.typeContext.newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true),
            originalType.lookupTag,
            type.lookupTag
        )
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.types.coneTypeSafe
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.AbstractTypeChecker
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext

 class FirTypeIntersectionScope private constructor(
    session: FirSession,
@@ -35,7 +34,7 @@ class FirTypeIntersectionScope private constructor(
    private val absentProperties: MutableSet<Name> = mutableSetOf()
    private val absentClassifiers: MutableSet<Name> = mutableSetOf()

-    private val typeCheckerContext = session.typeContext.newBaseTypeCheckerContext(false, false)
+    private val typeCheckerState = session.typeContext.newTypeCheckerState(false, false)

    private val overriddenSymbols: MutableMap<FirCallableSymbol<*>, Collection<MemberWithBaseScope<out FirCallableSymbol<*>>>> =
        mutableMapOf()
@@ -420,7 +419,7 @@ class FirTypeIntersectionScope private constructor(
            require(bFir is FirProperty) { "b is " + b.javaClass }
            // TODO: if (!OverridingUtil.isAccessorMoreSpecific(pa.getSetter(), pb.getSetter())) return false
            return if (aFir.isVar && bFir.isVar) {
-                AbstractTypeChecker.equalTypes(typeCheckerContext as AbstractTypeCheckerContext, aReturnType, bReturnType)
+                AbstractTypeChecker.equalTypes(typeCheckerState, aReturnType, bReturnType)
            } else { // both vals or var vs val: val can't be more specific then var
                !(!aFir.isVar && bFir.isVar) && isTypeMoreSpecific(aReturnType, bReturnType)
            }
@@ -429,7 +428,7 @@ class FirTypeIntersectionScope private constructor(
    }

    private fun isTypeMoreSpecific(a: ConeKotlinType, b: ConeKotlinType): Boolean =
-        AbstractTypeChecker.isSubtypeOf(typeCheckerContext as AbstractTypeCheckerContext, a, b)
+        AbstractTypeChecker.isSubtypeOf(typeCheckerState, a, b)

    private fun <D : FirCallableSymbol<*>> findMemberWithMaxVisibility(members: Collection<MemberWithBaseScope<D>>): MemberWithBaseScope<D> {
        assert(members.isNotEmpty())
@@ -106,11 +106,11 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo
        return ConeStarProjection
    }

-    override fun newBaseTypeCheckerContext(
+    override fun newTypeCheckerState(
        errorTypesEqualToAnything: Boolean,
        stubTypesEqualToAnything: Boolean
-    ): ConeTypeCheckerContext =
-        ConeTypeCheckerContext(errorTypesEqualToAnything, stubTypesEqualToAnything, this)
+    ): ConeTypeCheckerState =
+        ConeTypeCheckerState(errorTypesEqualToAnything, stubTypesEqualToAnything, this)

    override fun KotlinTypeMarker.canHaveUndefinedNullability(): Boolean {
        require(this is ConeKotlinType)
@@ -198,7 +198,7 @@ interface ConeInferenceContext : TypeSystemInferenceExtensionContext, ConeTypeCo
    override fun Collection<KotlinTypeMarker>.singleBestRepresentative(): KotlinTypeMarker? {
        if (this.size == 1) return this.first()

-        val context = newBaseTypeCheckerContext(errorTypesEqualToAnything = true, stubTypesEqualToAnything = true)
+        val context = newTypeCheckerState(errorTypesEqualToAnything = true, stubTypesEqualToAnything = true)
        return this.firstOrNull { candidate ->
            this.all { other ->
                // We consider error types equal to anything here, so that intersections like
@@ -6,14 +6,14 @@
 package org.jetbrains.kotlin.fir.types

 import org.jetbrains.kotlin.types.AbstractNullabilityChecker
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
+import org.jetbrains.kotlin.types.TypeCheckerState

 object ConeNullabilityChecker {
    fun isSubtypeOfAny(context: ConeTypeContext, type: ConeKotlinType): Boolean {
        val actualType = with(context) { type.lowerBoundIfFlexible() }
        return with(AbstractNullabilityChecker) {
-            context.newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
-                .hasNotNullSupertype(actualType, AbstractTypeCheckerContext.SupertypesPolicy.LowerIfFlexible)
+            context.newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
+                .hasNotNullSupertype(actualType, TypeCheckerState.SupertypesPolicy.LowerIfFlexible)
        }
    }
 }
@@ -31,9 +31,9 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext.SupertypesPolicy.DoCustomTransform
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext.SupertypesPolicy.LowerIfFlexible
+import org.jetbrains.kotlin.types.TypeCheckerState
+import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy.DoCustomTransform
+import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy.LowerIfFlexible
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
 import org.jetbrains.kotlin.types.model.*

@@ -567,12 +567,12 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
    }
 }

-class ConeTypeCheckerContext(
+class ConeTypeCheckerState(
    override val isErrorTypeEqualsToAnything: Boolean,
    override val isStubTypeEqualsToAnything: Boolean,
    override val typeSystemContext: ConeInferenceContext,
    val kotlinTypePreparator: ConeTypePreparator = ConeTypePreparator.getDefault(typeSystemContext.session),
-) : AbstractTypeCheckerContext() {
+) : TypeCheckerState() {

    val session: FirSession = typeSystemContext.session

@@ -595,7 +595,7 @@ class ConeTypeCheckerContext(
            ConeSubstitutor.Empty
        }
        return object : DoCustomTransform() {
-            override fun transformType(context: AbstractTypeCheckerContext, type: KotlinTypeMarker): SimpleTypeMarker {
+            override fun transformType(state: TypeCheckerState, type: KotlinTypeMarker): SimpleTypeMarker {
                val lowerBound = type.lowerBoundIfFlexible()
                require(lowerBound is ConeKotlinType)
                return substitutor.substituteOrSelf(lowerBound) as SimpleTypeMarker
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.typeContext
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
+import org.jetbrains.kotlin.types.TypeCheckerState
 import org.jetbrains.kotlin.types.model.CaptureStatus
 import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
@@ -29,24 +29,24 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess
    ): List<ConeClassLikeType>? {
        if (type !is ConeClassLikeType || supertypeConstructor !is ConeClassLikeLookupTag) return null

-        val context = session.typeContext.newBaseTypeCheckerContext(
+        val typeCheckerState = session.typeContext.newTypeCheckerState(
            errorTypesEqualToAnything = false,
            stubTypesEqualToAnything = true
        )

        val lookupTag = type.lookupTag
-        if (lookupTag == supertypeConstructor) return listOf(captureType(type, context.typeSystemContext))
+        if (lookupTag == supertypeConstructor) return listOf(captureType(type, typeCheckerState.typeSystemContext))
        if (lookupTag !in cache) {
-            cache[lookupTag] = computeSupertypesMap(lookupTag, context)
+            cache[lookupTag] = computeSupertypesMap(lookupTag, typeCheckerState)
        }

        val resultTypes = cache[lookupTag]?.getOrDefault(supertypeConstructor, emptyList()) ?: return null
        if (type.typeArguments.isEmpty()) return resultTypes

-        val capturedType = captureType(type, context.typeSystemContext)
-        val substitutionSupertypePolicy = context.substitutionSupertypePolicy(capturedType)
+        val capturedType = captureType(type, typeCheckerState.typeSystemContext)
+        val substitutionSupertypePolicy = typeCheckerState.substitutionSupertypePolicy(capturedType)
        return resultTypes.map {
-            substitutionSupertypePolicy.transformType(context, it) as ConeClassLikeType
+            substitutionSupertypePolicy.transformType(typeCheckerState, it) as ConeClassLikeType
        }
    }

@@ -55,7 +55,7 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess

    private fun computeSupertypesMap(
        subtypeLookupTag: ConeClassLikeLookupTag,
-        context: ConeTypeCheckerContext
+        state: ConeTypeCheckerState
    ): Map<ConeClassLikeLookupTag, List<ConeClassLikeType>>? {
        val resultingMap = HashMap<ConeClassLikeLookupTag, List<ConeClassLikeType>>()

@@ -68,10 +68,10 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess
            isNullable = false
        )

-        if (context.anySupertype(
+        if (state.anySupertype(
                defaultType,
                { it !is ConeClassLikeType || it.lookupTag.toSymbol(session) !is FirClassLikeSymbol<*> }
-            ) { supertype -> computeSupertypePolicyAndPutInMap(supertype, resultingMap, context) }
+            ) { supertype -> computeSupertypePolicyAndPutInMap(supertype, resultingMap, state) }
        ) {
            return null
        }
@@ -84,20 +84,20 @@ class FirCorrespondingSupertypesCache(private val session: FirSession) : FirSess
    private fun computeSupertypePolicyAndPutInMap(
        supertype: SimpleTypeMarker,
        resultingMap: MutableMap<ConeClassLikeLookupTag, List<ConeClassLikeType>>,
-        context: ConeTypeCheckerContext
-    ): AbstractTypeCheckerContext.SupertypesPolicy {
+        state: ConeTypeCheckerState
+    ): TypeCheckerState.SupertypesPolicy {
        val supertypeLookupTag = (supertype as ConeClassLikeType).lookupTag
        val captured =
-            context.typeSystemContext.captureFromArguments(supertype, CaptureStatus.FOR_SUBTYPING) as ConeClassLikeType? ?: supertype
+            state.typeSystemContext.captureFromArguments(supertype, CaptureStatus.FOR_SUBTYPING) as ConeClassLikeType? ?: supertype

        resultingMap[supertypeLookupTag] = listOf(captured)

        return when {
-            with(context.typeSystemContext) { captured.argumentsCount() } == 0 -> {
-                AbstractTypeCheckerContext.SupertypesPolicy.LowerIfFlexible
+            with(state.typeSystemContext) { captured.argumentsCount() } == 0 -> {
+                TypeCheckerState.SupertypesPolicy.LowerIfFlexible
            }
            else -> {
-                context.substitutionSupertypePolicy(captured)
+                state.substitutionSupertypePolicy(captured)
            }
        }
    }
@@ -55,7 +55,7 @@ fun ConeDefinitelyNotNullType.Companion.create(
    return when {
        original is ConeDefinitelyNotNullType -> original
        typeContext
-            .newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = false)
+            .newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = false)
            .makesSenseToBeDefinitelyNotNull(original, useCorrectedNullabilityForFlexibleTypeParameters) ->

            ConeDefinitelyNotNullType(