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

Remove all type system-specific inheritors of TypeCheckerState

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-08-25 14:20:08 +03:00
parent 3f6738c8bc
commit 7e6e0a3dd6
22 changed files with 193 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/compiler.common/src/org/jetbrains/kotlin/types/AbstractTypeChecker.kt
+8 -13
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.types
import org.jetbrains.kotlin.descriptors.containerRelation
import org.jetbrains.kotlin.types.TypeCheckerState.LowerCapturedTypePolicy.*
import org.jetbrains.kotlin.types.TypeCheckerState.SupertypesPolicy
import org.jetbrains.kotlin.types.model.*
@@ -22,14 +21,14 @@ import java.util.*
* Once some type-checker operation is performed using a [TypeCheckerProviderContext], for example a [AbstractTypeChecker.isSubtypeOf],
* new instance of particular [TypeCheckerState] should be created, with properly specified type system context
*/
abstract class TypeCheckerState {
abstract val kotlinTypePreparator: AbstractTypePreparator
abstract val kotlinTypeRefiner: AbstractTypeRefiner
abstract val typeSystemContext: TypeSystemContext
abstract val allowedTypeVariable: Boolean
open class TypeCheckerState(
val isErrorTypeEqualsToAnything: Boolean,
val isStubTypeEqualsToAnything: Boolean,
val allowedTypeVariable: Boolean,
val typeSystemContext: TypeSystemContext,
val kotlinTypePreparator: AbstractTypePreparator,
val kotlinTypeRefiner: AbstractTypeRefiner
) {
@OptIn(TypeRefinement::class)
fun refineType(type: KotlinTypeMarker): KotlinTypeMarker {
return kotlinTypeRefiner.refineType(type)
@@ -41,10 +40,6 @@ abstract class TypeCheckerState {
open fun customIsSubtypeOf(subType: KotlinTypeMarker, superType: KotlinTypeMarker): Boolean = true
abstract val isErrorTypeEqualsToAnything: Boolean
abstract val isStubTypeEqualsToAnything: Boolean
protected var argumentsDepth = 0
internal inline fun <T> runWithArgumentsSettings(subArgument: KotlinTypeMarker, f: TypeCheckerState.() -> T): T {
core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java
+15 -12
View File
@@ -32,7 +32,10 @@ import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl;
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.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.*;
@@ -308,7 +311,7 @@ public class OverridingUtil {
return OverrideCompatibilityInfo.conflict("Type parameter number mismatch");
}
Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker = createTypeChecker(superTypeParameters, subTypeParameters);
Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> typeChecker = createTypeChecker(superTypeParameters, subTypeParameters);
for (int i = 0; i < superTypeParameters.size(); i++) {
if (!areTypeParametersEquivalent(
@@ -384,7 +387,7 @@ public class OverridingUtil {
}
@NotNull
private Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> createTypeChecker(
private Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> createTypeChecker(
@NotNull List<TypeParameterDescriptor> firstParameters,
@NotNull List<TypeParameterDescriptor> secondParameters
) {
@@ -392,18 +395,18 @@ public class OverridingUtil {
"Should be the same number of type parameters: " + firstParameters + " vs " + secondParameters;
NewKotlinTypeCheckerImpl typeChecker = new NewKotlinTypeCheckerImpl(kotlinTypeRefiner, KotlinTypePreparator.Default.INSTANCE);
ClassicTypeCheckerState context = createTypeCheckerContext(firstParameters, secondParameters);
TypeCheckerState state = createTypeCheckerState(firstParameters, secondParameters);
return new Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState>(typeChecker, context);
return new Pair<NewKotlinTypeCheckerImpl, TypeCheckerState>(typeChecker, state);
}
@NotNull
private ClassicTypeCheckerState createTypeCheckerContext(
private TypeCheckerState createTypeCheckerState(
@NotNull List<TypeParameterDescriptor> firstParameters,
@NotNull List<TypeParameterDescriptor> secondParameters
) {
if (firstParameters.isEmpty()) {
return (ClassicTypeCheckerState) new OverridingUtilTypeSystemContext(null, equalityAxioms, kotlinTypeRefiner)
return new OverridingUtilTypeSystemContext(null, equalityAxioms, kotlinTypeRefiner)
.newTypeCheckerState(true, true);
}
@@ -412,7 +415,7 @@ public class OverridingUtil {
matchingTypeConstructors.put(firstParameters.get(i).getTypeConstructor(), secondParameters.get(i).getTypeConstructor());
}
return (ClassicTypeCheckerState) new OverridingUtilTypeSystemContext(matchingTypeConstructors, equalityAxioms, kotlinTypeRefiner)
return new OverridingUtilTypeSystemContext(matchingTypeConstructors, equalityAxioms, kotlinTypeRefiner)
.newTypeCheckerState(true, true);
}
@@ -435,7 +438,7 @@ public class OverridingUtil {
private boolean areTypesEquivalent(
@NotNull KotlinType typeInSuper,
@NotNull KotlinType typeInSub,
@NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
@NotNull Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> typeChecker
) {
boolean bothErrors = KotlinTypeKt.isError(typeInSuper) && KotlinTypeKt.isError(typeInSub);
if (bothErrors) return true;
@@ -446,7 +449,7 @@ public class OverridingUtil {
private boolean areTypeParametersEquivalent(
@NotNull TypeParameterDescriptor superTypeParameter,
@NotNull TypeParameterDescriptor subTypeParameter,
@NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
@NotNull Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> typeChecker
) {
List<KotlinType> superBounds = superTypeParameter.getUpperBounds();
List<KotlinType> subBounds = new ArrayList<KotlinType>(subTypeParameter.getUpperBounds());
@@ -584,7 +587,7 @@ public class OverridingUtil {
if (!isVisibilityMoreSpecific(a, b)) return false;
Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> checker =
Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> checker =
DEFAULT.createTypeChecker(a.getTypeParameters(), b.getTypeParameters());
if (a instanceof FunctionDescriptor) {
@@ -641,7 +644,7 @@ public class OverridingUtil {
@NotNull KotlinType aReturnType,
@NotNull CallableDescriptor b,
@NotNull KotlinType bReturnType,
@NotNull Pair<NewKotlinTypeCheckerImpl, ClassicTypeCheckerState> typeChecker
@NotNull Pair<NewKotlinTypeCheckerImpl, TypeCheckerState> typeChecker
) {
return typeChecker.getFirst().isSubtypeOf(typeChecker.getSecond(), aReturnType.unwrap(), bReturnType.unwrap());
}
core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtilTypeSystemContext.kt
+4 -4
View File
@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.resolve
import org.jetbrains.kotlin.types.TypeCheckerState
import org.jetbrains.kotlin.types.TypeConstructor
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
import org.jetbrains.kotlin.types.checker.createClassicTypeCheckerState
import org.jetbrains.kotlin.types.model.TypeConstructorMarker
class OverridingUtilTypeSystemContext(
@@ -29,11 +29,11 @@ class OverridingUtilTypeSystemContext(
errorTypesEqualToAnything: Boolean,
stubTypesEqualToAnything: Boolean
): TypeCheckerState {
return ClassicTypeCheckerState(
return createClassicTypeCheckerState(
errorTypesEqualToAnything,
stubTypesEqualToAnything,
kotlinTypeRefiner,
typeSystemContext = this
typeSystemContext = this,
kotlinTypeRefiner = kotlinTypeRefiner
)
}
core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeCheckerState.kt
+41 -16
View File
@@ -16,23 +16,48 @@
package org.jetbrains.kotlin.types.checker
import org.jetbrains.kotlin.types.*
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
import org.jetbrains.kotlin.types.model.SimpleTypeMarker
import org.jetbrains.kotlin.types.TypeCheckerState
@RequiresOptIn
annotation class ClassicTypeCheckerStateInternals
/**
* Class [ClassicTypeCheckerState] exists only to provide default arguments for
* cases when someone need to implement custom [TypeCheckerState] using default
* arguments. If you need to create only an instance of [TypeCheckerState] please
* use [createClassicTypeCheckerState] method.
*
* Also please don't use [ClassicTypeCheckerState] explicitly (except for inheritance)
*/
@ClassicTypeCheckerStateInternals
open class ClassicTypeCheckerState(
val errorTypeEqualsToAnything: Boolean,
val stubTypeEqualsToAnything: Boolean = true,
override val kotlinTypeRefiner: KotlinTypeRefiner = KotlinTypeRefiner.Default,
override val kotlinTypePreparator: KotlinTypePreparator = KotlinTypePreparator.Default,
override val typeSystemContext: ClassicTypeSystemContext = SimpleClassicTypeSystemContext
) : TypeCheckerState() {
override val isErrorTypeEqualsToAnything: Boolean
get() = errorTypeEqualsToAnything
isErrorTypeEqualsToAnything: Boolean,
isStubTypeEqualsToAnything: Boolean = true,
typeSystemContext: ClassicTypeSystemContext = SimpleClassicTypeSystemContext,
kotlinTypePreparator: KotlinTypePreparator = KotlinTypePreparator.Default,
kotlinTypeRefiner: KotlinTypeRefiner = KotlinTypeRefiner.Default
) : TypeCheckerState(
isErrorTypeEqualsToAnything,
isStubTypeEqualsToAnything,
allowedTypeVariable = true,
typeSystemContext,
kotlinTypePreparator,
kotlinTypeRefiner
)
override val isStubTypeEqualsToAnything: Boolean
get() = stubTypeEqualsToAnything
override val allowedTypeVariable: Boolean
get() = true
fun createClassicTypeCheckerState(
isErrorTypeEqualsToAnything: Boolean,
isStubTypeEqualsToAnything: Boolean = true,
typeSystemContext: ClassicTypeSystemContext = SimpleClassicTypeSystemContext,
kotlinTypePreparator: KotlinTypePreparator = KotlinTypePreparator.Default,
kotlinTypeRefiner: KotlinTypeRefiner = KotlinTypeRefiner.Default
): TypeCheckerState {
return TypeCheckerState(
isErrorTypeEqualsToAnything,
isStubTypeEqualsToAnything,
allowedTypeVariable = true,
typeSystemContext,
kotlinTypePreparator,
kotlinTypeRefiner
)
}
core/descriptors/src/org/jetbrains/kotlin/types/checker/ClassicTypeSystemContext.kt
+2 -2
View File
@@ -392,7 +392,7 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
errorTypesEqualToAnything: Boolean,
stubTypesEqualToAnything: Boolean
): TypeCheckerState {
return ClassicTypeCheckerState(errorTypesEqualToAnything, stubTypesEqualToAnything, typeSystemContext = this)
return createClassicTypeCheckerState(errorTypesEqualToAnything, stubTypesEqualToAnything, typeSystemContext = this)
}
override fun nullableNothingType(): SimpleTypeMarker {
@@ -411,7 +411,7 @@ interface ClassicTypeSystemContext : TypeSystemInferenceExtensionContext, TypeSy
return builtIns.anyType
}
open val builtIns: KotlinBuiltIns
val builtIns: KotlinBuiltIns
get() = throw UnsupportedOperationException("Not supported")
override fun KotlinTypeMarker.makeDefinitelyNotNullOrNotNull(): KotlinTypeMarker {
core/descriptors/src/org/jetbrains/kotlin/types/checker/NewKotlinTypeChecker.kt
+14 -11
View File
@@ -49,10 +49,14 @@ object StrictEqualityTypeChecker {
object ErrorTypesAreEqualToAnything : KotlinTypeChecker {
override fun isSubtypeOf(subtype: KotlinType, supertype: KotlinType): Boolean =
NewKotlinTypeChecker.Default.run { ClassicTypeCheckerState(true).isSubtypeOf(subtype.unwrap(), supertype.unwrap()) }
NewKotlinTypeChecker.Default.run {
createClassicTypeCheckerState(isErrorTypeEqualsToAnything = true).isSubtypeOf(subtype.unwrap(), supertype.unwrap())
}
override fun equalTypes(a: KotlinType, b: KotlinType): Boolean =
NewKotlinTypeChecker.Default.run { ClassicTypeCheckerState(true).equalTypes(a.unwrap(), b.unwrap()) }
NewKotlinTypeChecker.Default.run {
createClassicTypeCheckerState(isErrorTypeEqualsToAnything = true).equalTypes(a.unwrap(), b.unwrap())
}
}
interface NewKotlinTypeChecker : KotlinTypeChecker {
@@ -73,26 +77,25 @@ class NewKotlinTypeCheckerImpl(
override val overridingUtil: OverridingUtil = OverridingUtil.createWithTypeRefiner(kotlinTypeRefiner)
override fun isSubtypeOf(subtype: KotlinType, supertype: KotlinType): Boolean =
ClassicTypeCheckerState(
createClassicTypeCheckerState(
true, kotlinTypeRefiner = kotlinTypeRefiner, kotlinTypePreparator = kotlinTypePreparator
).isSubtypeOf(subtype.unwrap(), supertype.unwrap()) // todo fix flag errorTypeEqualsToAnything
override fun equalTypes(a: KotlinType, b: KotlinType): Boolean =
ClassicTypeCheckerState(
createClassicTypeCheckerState(
false, kotlinTypeRefiner = kotlinTypeRefiner, kotlinTypePreparator = kotlinTypePreparator
).equalTypes(a.unwrap(), b.unwrap())
fun ClassicTypeCheckerState.equalTypes(a: UnwrappedType, b: UnwrappedType): Boolean {
return AbstractTypeChecker.equalTypes(this as TypeCheckerState, a, b)
fun TypeCheckerState.equalTypes(a: UnwrappedType, b: UnwrappedType): Boolean {
return AbstractTypeChecker.equalTypes(this, a, b)
}
fun ClassicTypeCheckerState.isSubtypeOf(subType: UnwrappedType, superType: UnwrappedType): Boolean {
return AbstractTypeChecker.isSubtypeOf(this as TypeCheckerState, subType, superType)
fun TypeCheckerState.isSubtypeOf(subType: UnwrappedType, superType: UnwrappedType): Boolean {
return AbstractTypeChecker.isSubtypeOf(this, subType, superType)
}
}
object NullabilityChecker {
fun isSubtypeOfAny(type: UnwrappedType): Boolean =
SimpleClassicTypeSystemContext
.newTypeCheckerState(errorTypesEqualToAnything = false, stubTypesEqualToAnything = true)
@@ -100,13 +103,13 @@ object NullabilityChecker {
}
fun UnwrappedType.hasSupertypeWithGivenTypeConstructor(typeConstructor: TypeConstructor) =
ClassicTypeCheckerState(false).anySupertype(lowerIfFlexible(), {
createClassicTypeCheckerState(isErrorTypeEqualsToAnything = false).anySupertype(lowerIfFlexible(), {
require(it is SimpleType)
it.constructor == typeConstructor
}, { SupertypesPolicy.LowerIfFlexible })
fun UnwrappedType.anySuperTypeConstructor(predicate: (TypeConstructor) -> Boolean) =
ClassicTypeCheckerState(false).anySupertype(lowerIfFlexible(), {
createClassicTypeCheckerState(isErrorTypeEqualsToAnything = false).anySupertype(lowerIfFlexible(), {
require(it is SimpleType)
predicate(it.constructor)
}, { SupertypesPolicy.LowerIfFlexible })