Rename AbstractTypeCheckerContext to TypeCheckerState
This commit is contained in:
Dmitriy Novozhilov
+31
-31
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.types.AbstractFlexibilityChecker.hasDifferentFlexibi
|
||||
import org.jetbrains.kotlin.types.AbstractNullabilityChecker
|
||||
import org.jetbrains.kotlin.types.AbstractNullabilityChecker.hasPathByNotMarkedNullableNodes
|
||||
import org.jetbrains.kotlin.types.AbstractTypeChecker
|
||||
import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
|
||||
import org.jetbrains.kotlin.types.TypeCheckerState
|
||||
import org.jetbrains.kotlin.types.model.*
|
||||
|
||||
object NewCommonSuperTypeCalculator {
|
||||
@@ -47,14 +47,14 @@ object NewCommonSuperTypeCalculator {
|
||||
}
|
||||
}
|
||||
|
||||
val contextStubTypesEqualToAnything = newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
|
||||
val contextStubTypesNotEqual = newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = false)
|
||||
val stateStubTypesEqualToAnything = newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
|
||||
val stateStubTypesNotEqual = newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = false)
|
||||
|
||||
val lowerSuperType = commonSuperTypeForSimpleTypes(lowers, depth, contextStubTypesEqualToAnything, contextStubTypesNotEqual)
|
||||
val lowerSuperType = commonSuperTypeForSimpleTypes(lowers, depth, stateStubTypesEqualToAnything, stateStubTypesNotEqual)
|
||||
if (!thereIsFlexibleTypes) return lowerSuperType
|
||||
|
||||
val upperSuperType = commonSuperTypeForSimpleTypes(
|
||||
types.map { it.upperBoundIfFlexible() }, depth, contextStubTypesEqualToAnything, contextStubTypesNotEqual
|
||||
types.map { it.upperBoundIfFlexible() }, depth, stateStubTypesEqualToAnything, stateStubTypesNotEqual
|
||||
)
|
||||
|
||||
if (!isTopLevelType) {
|
||||
@@ -78,8 +78,8 @@ object NewCommonSuperTypeCalculator {
|
||||
private fun TypeSystemCommonSuperTypesContext.commonSuperTypeForSimpleTypes(
|
||||
types: List<SimpleTypeMarker>,
|
||||
depth: Int,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext,
|
||||
contextStubTypesNotEqual: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState,
|
||||
stateStubTypesNotEqual: TypeCheckerState
|
||||
): SimpleTypeMarker {
|
||||
if (types.any { it.isError() }) {
|
||||
return createErrorType("CST(${types.joinToString()}")
|
||||
@@ -87,10 +87,10 @@ object NewCommonSuperTypeCalculator {
|
||||
|
||||
// i.e. result type also should be marked nullable
|
||||
val notAllNotNull =
|
||||
types.any { !isTypeVariable(it) && !AbstractNullabilityChecker.isSubtypeOfAny(contextStubTypesEqualToAnything, it) }
|
||||
types.any { !isTypeVariable(it) && !AbstractNullabilityChecker.isSubtypeOfAny(stateStubTypesEqualToAnything, it) }
|
||||
val notNullTypes = if (notAllNotNull) types.map { it.withNullability(false) } else types
|
||||
|
||||
val commonSuperType = commonSuperTypeForNotNullTypes(notNullTypes, depth, contextStubTypesEqualToAnything, contextStubTypesNotEqual)
|
||||
val commonSuperType = commonSuperTypeForNotNullTypes(notNullTypes, depth, stateStubTypesEqualToAnything, stateStubTypesNotEqual)
|
||||
return if (notAllNotNull)
|
||||
refineNullabilityForUndefinedNullability(types, commonSuperType) ?: commonSuperType.withNullability(true)
|
||||
else
|
||||
@@ -115,12 +115,12 @@ object NewCommonSuperTypeCalculator {
|
||||
// Makes representative sample, i.e. (A, B, A) -> (A, B)
|
||||
private fun TypeSystemCommonSuperTypesContext.uniquify(
|
||||
types: List<SimpleTypeMarker>,
|
||||
contextStubTypesNotEqual: AbstractTypeCheckerContext
|
||||
stateStubTypesNotEqual: TypeCheckerState
|
||||
): List<SimpleTypeMarker> {
|
||||
val uniqueTypes = arrayListOf<SimpleTypeMarker>()
|
||||
for (type in types) {
|
||||
val isNewUniqueType = uniqueTypes.all {
|
||||
val equalsModuloFlexibility = AbstractTypeChecker.equalTypes(contextStubTypesNotEqual, it, type) &&
|
||||
val equalsModuloFlexibility = AbstractTypeChecker.equalTypes(stateStubTypesNotEqual, it, type) &&
|
||||
!it.typeConstructor().isIntegerLiteralTypeConstructor()
|
||||
|
||||
!equalsModuloFlexibility || hasDifferentFlexibilityAtDepth(listOf(it, type))
|
||||
@@ -136,7 +136,7 @@ object NewCommonSuperTypeCalculator {
|
||||
// Explanation: consider types (A : A0, B : B0, A0, B0), then CST(A, B, A0, B0) == CST(CST(A, A0), CST(B, B0)) == CST(A0, B0)
|
||||
private fun TypeSystemCommonSuperTypesContext.filterSupertypes(
|
||||
list: List<SimpleTypeMarker>,
|
||||
contextStubTypesNotEqual: AbstractTypeCheckerContext
|
||||
stateStubTypesNotEqual: TypeCheckerState
|
||||
): List<SimpleTypeMarker> {
|
||||
val supertypes = list.toMutableList()
|
||||
val iterator = supertypes.iterator()
|
||||
@@ -144,7 +144,7 @@ object NewCommonSuperTypeCalculator {
|
||||
val potentialSubtype = iterator.next()
|
||||
val isSubtype = supertypes.any { supertype ->
|
||||
supertype !== potentialSubtype &&
|
||||
AbstractTypeChecker.isSubtypeOf(contextStubTypesNotEqual, potentialSubtype, supertype) &&
|
||||
AbstractTypeChecker.isSubtypeOf(stateStubTypesNotEqual, potentialSubtype, supertype) &&
|
||||
!hasDifferentFlexibilityAtDepth(listOf(potentialSubtype, supertype))
|
||||
}
|
||||
|
||||
@@ -163,8 +163,8 @@ object NewCommonSuperTypeCalculator {
|
||||
private fun TypeSystemCommonSuperTypesContext.commonSuperTypeForNotNullTypes(
|
||||
types: List<SimpleTypeMarker>,
|
||||
depth: Int,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext,
|
||||
contextStubTypesNotEqual: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState,
|
||||
stateStubTypesNotEqual: TypeCheckerState
|
||||
): SimpleTypeMarker {
|
||||
if (types.size == 1) return types.single()
|
||||
|
||||
@@ -187,20 +187,20 @@ object NewCommonSuperTypeCalculator {
|
||||
if (uniqueStubTypes.size > 1) return nullableAnyType()
|
||||
|
||||
if (stubTypeVariables.none { it.isDefinitelyNotNullType() }) {
|
||||
return uniquify(stubTypeVariables.ifEmpty { types }, contextStubTypesNotEqual).singleOrNull() ?: return nullableAnyType()
|
||||
return uniquify(stubTypeVariables.ifEmpty { types }, stateStubTypesNotEqual).singleOrNull() ?: return nullableAnyType()
|
||||
}
|
||||
}
|
||||
|
||||
val uniqueTypes = uniquify(nonTypeVariables, contextStubTypesNotEqual)
|
||||
val uniqueTypes = uniquify(nonTypeVariables, stateStubTypesNotEqual)
|
||||
if (uniqueTypes.size == 1) return uniqueTypes.single()
|
||||
|
||||
val explicitSupertypes = filterSupertypes(uniqueTypes, contextStubTypesNotEqual)
|
||||
val explicitSupertypes = filterSupertypes(uniqueTypes, stateStubTypesNotEqual)
|
||||
if (explicitSupertypes.size == 1) return explicitSupertypes.single()
|
||||
findErrorTypeInSupertypes(explicitSupertypes, contextStubTypesEqualToAnything)?.let { return it }
|
||||
findErrorTypeInSupertypes(explicitSupertypes, stateStubTypesEqualToAnything)?.let { return it }
|
||||
|
||||
findCommonIntegerLiteralTypesSuperType(explicitSupertypes)?.let { return it }
|
||||
|
||||
return findSuperTypeConstructorsAndIntersectResult(explicitSupertypes, depth, contextStubTypesEqualToAnything)
|
||||
return findSuperTypeConstructorsAndIntersectResult(explicitSupertypes, depth, stateStubTypesEqualToAnything)
|
||||
}
|
||||
|
||||
private fun TypeSystemCommonSuperTypesContext.isTypeVariable(type: SimpleTypeMarker): Boolean {
|
||||
@@ -215,10 +215,10 @@ object NewCommonSuperTypeCalculator {
|
||||
|
||||
private fun TypeSystemCommonSuperTypesContext.findErrorTypeInSupertypes(
|
||||
types: List<SimpleTypeMarker>,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState
|
||||
): SimpleTypeMarker? {
|
||||
for (type in types) {
|
||||
collectAllSupertypes(type, contextStubTypesEqualToAnything).firstOrNull { it.isError() }?.let { return it.toErrorType() }
|
||||
collectAllSupertypes(type, stateStubTypesEqualToAnything).firstOrNull { it.isError() }?.let { return it.toErrorType() }
|
||||
}
|
||||
return null
|
||||
}
|
||||
@@ -226,10 +226,10 @@ object NewCommonSuperTypeCalculator {
|
||||
private fun TypeSystemCommonSuperTypesContext.findSuperTypeConstructorsAndIntersectResult(
|
||||
types: List<SimpleTypeMarker>,
|
||||
depth: Int,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState
|
||||
): SimpleTypeMarker =
|
||||
intersectTypes(
|
||||
allCommonSuperTypeConstructors(types, contextStubTypesEqualToAnything)
|
||||
allCommonSuperTypeConstructors(types, stateStubTypesEqualToAnything)
|
||||
.map { superTypeWithGivenConstructor(types, it, depth) }
|
||||
)
|
||||
|
||||
@@ -238,14 +238,14 @@ object NewCommonSuperTypeCalculator {
|
||||
*/
|
||||
private fun TypeSystemCommonSuperTypesContext.allCommonSuperTypeConstructors(
|
||||
types: List<SimpleTypeMarker>,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState
|
||||
): List<TypeConstructorMarker> {
|
||||
val result = collectAllSupertypes(types.first(), contextStubTypesEqualToAnything)
|
||||
val result = collectAllSupertypes(types.first(), stateStubTypesEqualToAnything)
|
||||
// retain all super constructors of the first type that are present in the supertypes of all other types
|
||||
for (type in types) {
|
||||
if (type === types.first()) continue
|
||||
|
||||
result.retainAll(collectAllSupertypes(type, contextStubTypesEqualToAnything))
|
||||
result.retainAll(collectAllSupertypes(type, stateStubTypesEqualToAnything))
|
||||
}
|
||||
// remove all constructors that have subtype(s) with constructors from the resulting set - they are less precise
|
||||
return result.filterNot { target ->
|
||||
@@ -257,13 +257,13 @@ object NewCommonSuperTypeCalculator {
|
||||
|
||||
private fun TypeSystemCommonSuperTypesContext.collectAllSupertypes(
|
||||
type: SimpleTypeMarker,
|
||||
contextStubTypesEqualToAnything: AbstractTypeCheckerContext
|
||||
stateStubTypesEqualToAnything: TypeCheckerState
|
||||
) =
|
||||
LinkedHashSet<TypeConstructorMarker>().apply {
|
||||
contextStubTypesEqualToAnything.anySupertype(
|
||||
stateStubTypesEqualToAnything.anySupertype(
|
||||
type,
|
||||
{ add(it.typeConstructor()); false },
|
||||
{ AbstractTypeCheckerContext.SupertypesPolicy.LowerIfFlexible }
|
||||
{ TypeCheckerState.SupertypesPolicy.LowerIfFlexible }
|
||||
)
|
||||
}
|
||||
|
||||
@@ -278,7 +278,7 @@ object NewCommonSuperTypeCalculator {
|
||||
nullable = false
|
||||
)
|
||||
|
||||
val typeCheckerContext = newBaseTypeCheckerContext(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
|
||||
val typeCheckerContext = newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
|
||||
|
||||
/**
|
||||
* Sometimes one type can have several supertypes with given type constructor, suppose A <: List<Int> and A <: List<Double>.
|
||||
|
||||
+35
-35
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.*
|
||||
import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintKind.*
|
||||
import org.jetbrains.kotlin.types.AbstractTypeApproximator
|
||||
import org.jetbrains.kotlin.types.AbstractTypeChecker
|
||||
import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
|
||||
import org.jetbrains.kotlin.types.TypeCheckerState
|
||||
import org.jetbrains.kotlin.types.TypeApproximatorConfiguration
|
||||
import org.jetbrains.kotlin.types.model.*
|
||||
import org.jetbrains.kotlin.utils.SmartList
|
||||
@@ -43,23 +43,23 @@ class ConstraintInjector(
|
||||
|
||||
fun addInitialSubtypeConstraint(c: Context, lowerType: KotlinTypeMarker, upperType: KotlinTypeMarker, position: ConstraintPosition) {
|
||||
val initialConstraint = InitialConstraint(lowerType, upperType, UPPER, position).also { c.addInitialConstraint(it) }
|
||||
val typeCheckerContext = TypeCheckerContext(c, IncorporationConstraintPosition(position, initialConstraint))
|
||||
val typeCheckerState = TypeCheckerStateForConstraintInjector(c, IncorporationConstraintPosition(position, initialConstraint))
|
||||
|
||||
updateAllowedTypeDepth(c, lowerType)
|
||||
updateAllowedTypeDepth(c, upperType)
|
||||
|
||||
addSubTypeConstraintAndIncorporateIt(c, lowerType, upperType, typeCheckerContext)
|
||||
addSubTypeConstraintAndIncorporateIt(c, lowerType, upperType, typeCheckerState)
|
||||
}
|
||||
|
||||
private fun Context.addInitialEqualityConstraintThroughSubtyping(
|
||||
a: KotlinTypeMarker,
|
||||
b: KotlinTypeMarker,
|
||||
typeCheckerContext: TypeCheckerContext
|
||||
typeCheckerState: TypeCheckerStateForConstraintInjector
|
||||
) {
|
||||
updateAllowedTypeDepth(this, a)
|
||||
updateAllowedTypeDepth(this, b)
|
||||
addSubTypeConstraintAndIncorporateIt(this, a, b, typeCheckerContext)
|
||||
addSubTypeConstraintAndIncorporateIt(this, b, a, typeCheckerContext)
|
||||
addSubTypeConstraintAndIncorporateIt(this, a, b, typeCheckerState)
|
||||
addSubTypeConstraintAndIncorporateIt(this, b, a, typeCheckerState)
|
||||
}
|
||||
|
||||
fun addInitialEqualityConstraint(c: Context, a: KotlinTypeMarker, b: KotlinTypeMarker, position: ConstraintPosition) = with(c) {
|
||||
@@ -69,32 +69,32 @@ class ConstraintInjector(
|
||||
else -> return
|
||||
}
|
||||
val initialConstraint = InitialConstraint(typeVariable, equalType, EQUALITY, position).also { c.addInitialConstraint(it) }
|
||||
val typeCheckerContext = TypeCheckerContext(c, IncorporationConstraintPosition(position, initialConstraint))
|
||||
val typeCheckerState = TypeCheckerStateForConstraintInjector(c, IncorporationConstraintPosition(position, initialConstraint))
|
||||
|
||||
// We add constraints like `T? == Foo!` in the old way
|
||||
if (!typeVariable.isSimpleType() || typeVariable.isMarkedNullable()) {
|
||||
addInitialEqualityConstraintThroughSubtyping(typeVariable, equalType, typeCheckerContext)
|
||||
addInitialEqualityConstraintThroughSubtyping(typeVariable, equalType, typeCheckerState)
|
||||
return
|
||||
}
|
||||
|
||||
updateAllowedTypeDepth(c, equalType)
|
||||
addEqualityConstraintAndIncorporateIt(c, typeVariable, equalType, typeCheckerContext)
|
||||
addEqualityConstraintAndIncorporateIt(c, typeVariable, equalType, typeCheckerState)
|
||||
}
|
||||
|
||||
private fun addSubTypeConstraintAndIncorporateIt(
|
||||
c: Context,
|
||||
lowerType: KotlinTypeMarker,
|
||||
upperType: KotlinTypeMarker,
|
||||
typeCheckerContext: TypeCheckerContext
|
||||
typeCheckerState: TypeCheckerStateForConstraintInjector
|
||||
) {
|
||||
typeCheckerContext.setConstrainingTypesToPrintDebugInfo(lowerType, upperType)
|
||||
typeCheckerContext.runIsSubtypeOf(lowerType, upperType)
|
||||
typeCheckerState.setConstrainingTypesToPrintDebugInfo(lowerType, upperType)
|
||||
typeCheckerState.runIsSubtypeOf(lowerType, upperType)
|
||||
|
||||
// Missed constraints are constraints which we skipped in the constraints processor by mistake (incorrect optimization)
|
||||
val missedConstraints = processConstraints(c, typeCheckerContext)
|
||||
val missedConstraints = processConstraints(c, typeCheckerState)
|
||||
|
||||
if (missedConstraints != null) {
|
||||
c.addMissedConstraints(typeCheckerContext.position, missedConstraints)
|
||||
c.addMissedConstraints(typeCheckerState.position, missedConstraints)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -102,16 +102,16 @@ class ConstraintInjector(
|
||||
c: Context,
|
||||
typeVariable: KotlinTypeMarker,
|
||||
equalType: KotlinTypeMarker,
|
||||
typeCheckerContext: TypeCheckerContext
|
||||
typeCheckerState: TypeCheckerStateForConstraintInjector
|
||||
) {
|
||||
typeCheckerContext.setConstrainingTypesToPrintDebugInfo(typeVariable, equalType)
|
||||
typeCheckerContext.addEqualityConstraint(typeVariable.typeConstructor(c), equalType)
|
||||
typeCheckerState.setConstrainingTypesToPrintDebugInfo(typeVariable, equalType)
|
||||
typeCheckerState.addEqualityConstraint(typeVariable.typeConstructor(c), equalType)
|
||||
|
||||
// Missed constraints are constraints which we skipped in the constraints processor by mistake (incorrect optimization)
|
||||
val missedConstraints = processConstraints(c, typeCheckerContext)
|
||||
val missedConstraints = processConstraints(c, typeCheckerState)
|
||||
|
||||
if (missedConstraints != null) {
|
||||
c.addMissedConstraints(typeCheckerContext.position, missedConstraints)
|
||||
c.addMissedConstraints(typeCheckerState.position, missedConstraints)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -126,23 +126,23 @@ class ConstraintInjector(
|
||||
// If proper constraints processing is enabled, then we don't have missed constraints
|
||||
if (properConstraintsProcessingEnabled) return
|
||||
|
||||
val typeCheckerContext = TypeCheckerContext(c, position)
|
||||
val typeCheckerState = TypeCheckerStateForConstraintInjector(c, position)
|
||||
for ((variable, constraint) in missedConstraints) {
|
||||
typeCheckerContext.addPossibleNewConstraint(variable, constraint)
|
||||
typeCheckerState.addPossibleNewConstraint(variable, constraint)
|
||||
}
|
||||
processConstraints(c, typeCheckerContext, skipProperEqualityConstraints = false)
|
||||
processConstraints(c, typeCheckerState, skipProperEqualityConstraints = false)
|
||||
}
|
||||
|
||||
private fun processConstraints(
|
||||
c: Context,
|
||||
typeCheckerContext: TypeCheckerContext,
|
||||
typeCheckerState: TypeCheckerStateForConstraintInjector,
|
||||
skipProperEqualityConstraints: Boolean = true
|
||||
): MutableList<Pair<TypeVariableMarker, Constraint>>? {
|
||||
val properConstraintsProcessingEnabled =
|
||||
languageVersionSettings.supportsFeature(LanguageFeature.ProperTypeInferenceConstraintsProcessing)
|
||||
|
||||
while (typeCheckerContext.hasConstraintsToProcess()) {
|
||||
processGivenConstraints(c, typeCheckerContext, typeCheckerContext.extractAllConstraints()!!)
|
||||
while (typeCheckerState.hasConstraintsToProcess()) {
|
||||
processGivenConstraints(c, typeCheckerState, typeCheckerState.extractAllConstraints()!!)
|
||||
|
||||
val contextOps = c as? ConstraintSystemOperation
|
||||
|
||||
@@ -157,21 +157,21 @@ class ConstraintInjector(
|
||||
}
|
||||
}
|
||||
|
||||
if (hasProperEqualityConstraintForEachVariable) return typeCheckerContext.extractAllConstraints()
|
||||
if (hasProperEqualityConstraintForEachVariable) return typeCheckerState.extractAllConstraints()
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun processGivenConstraints(
|
||||
c: Context,
|
||||
typeCheckerContext: TypeCheckerContext,
|
||||
typeCheckerState: TypeCheckerStateForConstraintInjector,
|
||||
constraintsToProcess: MutableList<Pair<TypeVariableMarker, Constraint>>
|
||||
) {
|
||||
for ((typeVariable, constraint) in constraintsToProcess) {
|
||||
if (c.shouldWeSkipConstraint(typeVariable, constraint)) continue
|
||||
|
||||
val constraints =
|
||||
c.notFixedTypeVariables[typeVariable.freshTypeConstructor(c)] ?: typeCheckerContext.fixedTypeVariable(typeVariable)
|
||||
c.notFixedTypeVariables[typeVariable.freshTypeConstructor(c)] ?: typeCheckerState.fixedTypeVariable(typeVariable)
|
||||
|
||||
// it is important, that we add constraint here(not inside TypeCheckerContext), because inside incorporation we read constraints
|
||||
val (addedOrNonRedundantExistedConstraint, wasAdded) = constraints.addConstraint(constraint)
|
||||
@@ -184,7 +184,7 @@ class ConstraintInjector(
|
||||
}
|
||||
|
||||
if (constraintToIncorporate != null) {
|
||||
constraintIncorporator.incorporate(typeCheckerContext, typeVariable, constraintToIncorporate)
|
||||
constraintIncorporator.incorporate(typeCheckerState, typeVariable, constraintToIncorporate)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -217,8 +217,8 @@ class ConstraintInjector(
|
||||
private fun Context.isAllowedType(type: KotlinTypeMarker) =
|
||||
type.typeDepth() <= maxTypeDepthFromInitialConstraints + ALLOWED_DEPTH_DELTA_FOR_INCORPORATION
|
||||
|
||||
private inner class TypeCheckerContext(val c: Context, val position: IncorporationConstraintPosition) :
|
||||
AbstractTypeCheckerContextForConstraintSystem(c), ConstraintIncorporator.Context, TypeSystemInferenceExtensionContext by c {
|
||||
private inner class TypeCheckerStateForConstraintInjector(val c: Context, val position: IncorporationConstraintPosition) :
|
||||
TypeCheckerStateForConstraintSystem(c), ConstraintIncorporator.Context, TypeSystemInferenceExtensionContext by c {
|
||||
// We use `var` intentionally to avoid extra allocations as this property is quite "hot"
|
||||
private var possibleNewConstraints: MutableList<Pair<TypeVariableMarker, Constraint>>? = null
|
||||
|
||||
@@ -245,10 +245,10 @@ class ConstraintInjector(
|
||||
baseUpperType = upperType
|
||||
}
|
||||
|
||||
val baseContext: AbstractTypeCheckerContext = newBaseTypeCheckerContext(isErrorTypeEqualsToAnything, isStubTypeEqualsToAnything)
|
||||
val baseState: TypeCheckerState = newTypeCheckerState(isErrorTypeEqualsToAnything, isStubTypeEqualsToAnything)
|
||||
|
||||
override fun substitutionSupertypePolicy(type: SimpleTypeMarker): SupertypesPolicy {
|
||||
return baseContext.substitutionSupertypePolicy(type)
|
||||
return baseState.substitutionSupertypePolicy(type)
|
||||
}
|
||||
|
||||
override fun refineType(type: KotlinTypeMarker): KotlinTypeMarker {
|
||||
@@ -257,7 +257,7 @@ class ConstraintInjector(
|
||||
}
|
||||
}
|
||||
|
||||
override fun prepareType(type: KotlinTypeMarker) = baseContext.prepareType(type)
|
||||
override fun prepareType(type: KotlinTypeMarker) = baseState.prepareType(type)
|
||||
|
||||
fun runIsSubtypeOf(
|
||||
lowerType: KotlinTypeMarker,
|
||||
@@ -267,7 +267,7 @@ class ConstraintInjector(
|
||||
) {
|
||||
fun isSubtypeOf(upperType: KotlinTypeMarker) =
|
||||
AbstractTypeChecker.isSubtypeOf(
|
||||
this@TypeCheckerContext as AbstractTypeCheckerContext,
|
||||
this@TypeCheckerStateForConstraintInjector as TypeCheckerState,
|
||||
lowerType,
|
||||
upperType,
|
||||
isFromNullabilityConstraint
|
||||
|
||||
+6
-6
@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.resolve.calls.inference.components
|
||||
|
||||
import org.jetbrains.kotlin.types.AbstractNullabilityChecker
|
||||
import org.jetbrains.kotlin.types.AbstractTypeChecker
|
||||
import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
|
||||
import org.jetbrains.kotlin.types.TypeCheckerState
|
||||
import org.jetbrains.kotlin.types.model.*
|
||||
|
||||
abstract class AbstractTypeCheckerContextForConstraintSystem(override val typeSystemContext: TypeSystemInferenceExtensionContext) :
|
||||
AbstractTypeCheckerContext() {
|
||||
abstract class TypeCheckerStateForConstraintSystem(override val typeSystemContext: TypeSystemInferenceExtensionContext) :
|
||||
TypeCheckerState() {
|
||||
|
||||
override val KotlinTypeMarker.isAllowedTypeVariable: Boolean
|
||||
get() = false
|
||||
@@ -99,10 +99,10 @@ abstract class AbstractTypeCheckerContextForConstraintSystem(override val typeSy
|
||||
}
|
||||
|
||||
private fun KotlinTypeMarker.isTypeVariableWithExact() =
|
||||
with(typeSystemContext) { hasExactAnnotation() } && anyBound(this@AbstractTypeCheckerContextForConstraintSystem::isMyTypeVariable)
|
||||
with(typeSystemContext) { hasExactAnnotation() } && anyBound(this@TypeCheckerStateForConstraintSystem::isMyTypeVariable)
|
||||
|
||||
private fun KotlinTypeMarker.isTypeVariableWithNoInfer() =
|
||||
with(typeSystemContext) { hasNoInferAnnotation() } && anyBound(this@AbstractTypeCheckerContextForConstraintSystem::isMyTypeVariable)
|
||||
with(typeSystemContext) { hasNoInferAnnotation() } && anyBound(this@TypeCheckerStateForConstraintSystem::isMyTypeVariable)
|
||||
|
||||
private fun internalAddSubtypeConstraint(
|
||||
subType: KotlinTypeMarker,
|
||||
@@ -333,7 +333,7 @@ abstract class AbstractTypeCheckerContextForConstraintSystem(override val typeSy
|
||||
}
|
||||
|
||||
private fun isSubtypeOfByTypeChecker(subType: KotlinTypeMarker, superType: KotlinTypeMarker) =
|
||||
AbstractTypeChecker.isSubtypeOf(this as AbstractTypeCheckerContext, subType, superType)
|
||||
AbstractTypeChecker.isSubtypeOf(this as TypeCheckerState, subType, superType)
|
||||
|
||||
private fun assertInputTypes(subType: KotlinTypeMarker, superType: KotlinTypeMarker) = with(typeSystemContext) {
|
||||
if (!AbstractTypeChecker.RUN_SLOW_ASSERTIONS) return
|
||||
-1
@@ -5,7 +5,6 @@
|
||||
|
||||
package org.jetbrains.kotlin.resolve.calls.inference.model
|
||||
|
||||
import org.jetbrains.kotlin.resolve.calls.inference.components.AbstractTypeCheckerContextForConstraintSystem
|
||||
import org.jetbrains.kotlin.resolve.calls.inference.components.ConstraintSystemUtilContext
|
||||
import org.jetbrains.kotlin.resolve.calls.tower.isSuccess
|
||||
import org.jetbrains.kotlin.types.model.*
|
||||
|
||||
+1
-1
@@ -174,7 +174,7 @@ abstract class AbstractTypeApproximator(
|
||||
val needApproximate = conf.localTypes && constructor.isLocalType()
|
||||
if (!needApproximate) return null
|
||||
val superConstructor = constructor.supertypes().first().typeConstructor()
|
||||
val typeCheckerContext = newBaseTypeCheckerContext(
|
||||
val typeCheckerContext = newTypeCheckerState(
|
||||
errorTypesEqualToAnything = false,
|
||||
stubTypesEqualToAnything = false
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user