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

[FIR] Fix all illegal usages of declarationSiteSession in compiler

Browse Source 
There are still some usages in IDE which should be investigated
This commit is contained in:
Dmitriy Novozhilov
2021-04-21 13:26:40 +03:00
committed by TeamCityServer
parent f98f41bbc3
commit 234ab3b35d
53 changed files with 191 additions and 204 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt
+3 -2
View File
@@ -44,6 +44,7 @@ import kotlin.contracts.contract
object FirCallsEffectAnalyzer : FirControlFlowChecker() {
override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, context: CheckerContext) {
val session = context.session
val function = (graph.declaration as? FirFunction<*>) ?: return
if (function !is FirContractDescriptionOwner) return
if (function.contractDescription.coneEffects?.any { it is ConeCallsEffectDeclaration } != true) return
@@ -51,13 +52,13 @@ object FirCallsEffectAnalyzer : FirControlFlowChecker() {
val functionalTypeEffects = mutableMapOf<AbstractFirBasedSymbol<*>, ConeCallsEffectDeclaration>()
function.valueParameters.forEachIndexed { index, parameter ->
if (parameter.returnTypeRef.isFunctionalTypeRef(function.declarationSiteSession)) {
if (parameter.returnTypeRef.isFunctionalTypeRef(session)) {
val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(index)
if (effectDeclaration != null) functionalTypeEffects[parameter.symbol] = effectDeclaration
}
}
if (function.receiverTypeRef.isFunctionalTypeRef(function.declarationSiteSession)) {
if (function.receiverTypeRef.isFunctionalTypeRef(session)) {
val effectDeclaration = function.contractDescription.getParameterCallsEffectDeclaration(-1)
if (effectDeclaration != null) functionalTypeEffects[function.symbol] = effectDeclaration
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt
+5 -7
View File
@@ -33,8 +33,6 @@ import org.jetbrains.kotlin.fir.types.intersectTypesOrNull
import org.jetbrains.kotlin.fir.types.isNullable
import org.jetbrains.kotlin.types.AbstractTypeChecker
import org.jetbrains.kotlin.types.ConstantValueKind
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
import org.jetbrains.kotlin.types.model.TypeCheckerProviderContext
import org.jetbrains.kotlin.utils.addIfNotNull
object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
@@ -50,7 +48,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
if (effects.isNullOrEmpty()) return
val logicSystem = object : PersistentLogicSystem(function.declarationSiteSession.typeContext) {
val logicSystem = object : PersistentLogicSystem(context.session.typeContext) {
override fun processUpdatedReceiverVariable(flow: PersistentFlow, variable: RealVariable) =
throw IllegalStateException("Receiver variable update is not possible for this logic system")
@@ -84,8 +82,8 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
context: CheckerContext
): Boolean {
val effect = effectDeclaration.effect as ConeReturnsEffectDeclaration
val builtinTypes = function.declarationSiteSession.builtinTypes
val typeContext = function.declarationSiteSession.typeContext
val builtinTypes = context.session.builtinTypes
val typeContext = context.session.typeContext
val flow = dataFlowInfo.flowOnNodes.getValue(node) as PersistentFlow
val isReturn = node is JumpNode && node.fir is FirReturnExpression
@@ -104,7 +102,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
if (effect.value != ConeConstantReference.WILDCARD) {
val operation = effect.value.toOperation()
if (expressionType != null && expressionType.isInapplicableWith(operation, function.declarationSiteSession)) return false
if (expressionType != null && expressionType.isInapplicableWith(operation, context.session)) return false
if (resultExpression is FirConstExpression<*>) {
if (!resultExpression.isApplicableWith(operation)) return false
@@ -179,7 +177,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() {
is ConeIsNullPredicate -> {
val fir = function.getParameterSymbol(arg.parameterIndex, context).fir
val realVar = variableStorage.getOrCreateRealVariable(flow, fir.symbol, fir)
realVar?.to(simpleTypeStatement(realVar, isNegated, function.declarationSiteSession.builtinTypes.anyType.type))?.let { mutableMapOf(it) }
realVar?.to(simpleTypeStatement(realVar, isNegated, context.session.builtinTypes.anyType.type))?.let { mutableMapOf(it) }
}
is ConeLogicalNot -> arg.buildTypeStatements(function, logicSystem, variableStorage, flow, context)
?.mapValuesTo(mutableMapOf()) { (_, value) -> value.invert() }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+3 -37
View File
@@ -53,51 +53,17 @@ private val INLINE_ONLY_ANNOTATION_CLASS_ID = ClassId.topLevel(FqName("kotlin.in
internal fun FirClass<*>.unsubstitutedScope(context: CheckerContext) =
this.unsubstitutedScope(context.sessionHolder.session, context.sessionHolder.scopeSession, withForcedTypeCalculator = false)
/**
* Returns true if this is a superclass of other.
*/
fun FirClass<*>.isSuperclassOf(other: FirClass<*>): Boolean {
/**
* Hides additional parameters.
*/
fun FirClass<*>.isSuperclassOf(other: FirClass<*>, exclude: MutableSet<FirClass<*>>): Boolean {
for (it in other.superTypeRefs) {
val that = it.firClassLike(declarationSiteSession)
?.followAllAlias(declarationSiteSession)
?.safeAs<FirClass<*>>()
?: continue
if (that in exclude) {
continue
}
if (that.classKind == ClassKind.CLASS) {
if (that == this) {
return true
}
exclude.add(that)
return this.isSuperclassOf(that, exclude)
}
}
return false
}
return isSuperclassOf(other, mutableSetOf())
}
/**
* Returns true if this is a supertype of other.
*/
fun FirClass<*>.isSupertypeOf(other: FirClass<*>): Boolean {
fun FirClass<*>.isSupertypeOf(other: FirClass<*>, session: FirSession): Boolean {
/**
* Hides additional parameters.
*/
fun FirClass<*>.isSupertypeOf(other: FirClass<*>, exclude: MutableSet<FirClass<*>>): Boolean {
for (it in other.superTypeRefs) {
val candidate = it.firClassLike(declarationSiteSession)
?.followAllAlias(declarationSiteSession)
val candidate = it.firClassLike(session)
?.followAllAlias(session)
?.safeAs<FirClass<*>>()
?: continue
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt
+1 -1
View File
@@ -44,7 +44,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
val isInterface = declaration.classKind == ClassKind.INTERFACE
for (supertypeRef in supertypes) {
val supertype = supertypeRef.coneTypeSafe<ConeClassLikeType>() ?: continue
val clazz = supertype.toRegularClass(declaration.declarationSiteSession) ?: continue
val clazz = supertype.toRegularClass(context.session) ?: continue
val superIsInterface = clazz.classKind == ClassKind.INTERFACE
if (superIsInterface != isInterface) {
continue
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt
+2 -2
View File
@@ -50,7 +50,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
}
}
if (declaration.isSubtypeOfCloneable()) {
if (declaration.isSubtypeOfCloneable(context.session)) {
reporter.reportOn(declaration.source, FirErrors.VALUE_CLASS_CANNOT_BE_CLONEABLE, context)
}
@@ -210,7 +210,7 @@ object FirInlineClassDeclarationChecker : FirRegularClassChecker() {
?.isRecursiveInlineClassType(visited, session) == true
}
private fun FirRegularClass.isSubtypeOfCloneable(): Boolean {
private fun FirRegularClass.isSubtypeOfCloneable(session: FirSession): Boolean {
if (classId.isCloneableId()) return true
return lookupSuperTypes(this, lookupInterfaces = true, deep = true, session).any { superType ->
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt
+3 -2
View File
@@ -59,6 +59,7 @@ object FirOverrideChecker : FirClassChecker() {
private fun ConeKotlinType.substituteAllTypeParameters(
overrideDeclaration: FirCallableMemberDeclaration<*>,
baseDeclaration: FirCallableDeclaration<*>,
context: CheckerContext
): ConeKotlinType {
if (overrideDeclaration.typeParameters.isEmpty()) {
return this
@@ -77,7 +78,7 @@ object FirOverrideChecker : FirClassChecker() {
map[from.symbol] = to.toConeType()
}
return substitutorByMap(map).substituteOrSelf(this)
return substitutorByMap(map, context.session).substituteOrSelf(this)
}
private fun checkModality(
@@ -144,7 +145,7 @@ object FirOverrideChecker : FirClassChecker() {
for (it in bounds.indices) {
val overriddenDeclaration = overriddenSymbols[it].fir
val overriddenReturnType = bounds[it].substituteAllTypeParameters(this, overriddenDeclaration)
val overriddenReturnType = bounds[it].substituteAllTypeParameters(this, overriddenDeclaration, context)
val isReturnTypeOkForOverride =
if (overriddenDeclaration is FirProperty && overriddenDeclaration.isVar)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt
+2 -2
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.resolve.containingClass
import org.jetbrains.kotlin.fir.resolve.getContainingClass
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
object FirCallableReferenceChecker : FirQualifiedAccessChecker() {
@@ -43,7 +43,7 @@ object FirCallableReferenceChecker : FirQualifiedAccessChecker() {
if (source.kind is FirFakeSourceElementKind) return
val referredDeclaration = reference.resolvedSymbol.fir
if (referredDeclaration is FirConstructor && referredDeclaration.containingClass?.classKind == ClassKind.ANNOTATION_CLASS) {
if (referredDeclaration is FirConstructor && referredDeclaration.getContainingClass(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) {
reporter.reportOn(source, FirErrors.CALLABLE_REFERENCE_TO_ANNOTATION_CONSTRUCTOR, context)
}
if ((referredDeclaration as? FirCallableMemberDeclaration<*>)?.isExtensionMember == true &&
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt
+1 -1
View File
@@ -28,7 +28,7 @@ object FirNotASupertypeChecker : FirQualifiedAccessChecker() {
?: return
val surrounding = context.findClosestClass(superReference.labelName) ?: return
if (!targetClass.isSupertypeOf(surrounding)) {
if (!targetClass.isSupertypeOf(surrounding, context.session)) {
reporter.reportOn(expression.source, FirErrors.NOT_A_SUPERTYPE, context)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt
+1 -1
View File
@@ -44,7 +44,7 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess
?.followAllAlias(context.session).safeAs<FirClass<*>>()
?: continue
val isSupertype = explicitType.isSupertypeOf(that)
val isSupertype = explicitType.isSupertypeOf(that, context.session)
if (explicitType == that || isSupertype) {
if (isSupertype) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt
+6 -3
View File
@@ -59,7 +59,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
// we substitute actual values to the
// type parameters from the declaration
val substitutor = substitutorByMap(
parameterPairs.mapValues { it.value.coneType }
parameterPairs.mapValues { it.value.coneType },
context.session
)
parameterPairs.forEach { (proto, actual) ->
@@ -147,7 +148,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
// parameters to the ones used in the
// typealias target
val declarationSiteSubstitutor = substitutorByMap(
constructorsParameterPairs.toMap().mapValues { it.value.type }
constructorsParameterPairs.toMap().mapValues { it.value.type },
context.session
)
constructorsParameterPairs.forEach { (proto, actual) ->
@@ -209,7 +211,8 @@ object FirUpperBoundViolatedChecker : FirQualifiedAccessChecker() {
}
val substitutor = substitutorByMap(
parameterPairs.toMap().mapValues { it.value.type }
parameterPairs.toMap().mapValues { it.value.type },
context.session
)
parameterPairs.forEach { (proto, actual) ->
compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt
+1 -1
View File
@@ -40,7 +40,7 @@ fun FirSession.registerCommonComponents(languageVersionSettings: LanguageVersion
register(FirLanguageSettingsComponent::class, FirLanguageSettingsComponent(languageVersionSettings))
register(InferenceComponents::class, InferenceComponents(this))
register(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider())
register(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider(this))
register(FirCorrespondingSupertypesCache::class, FirCorrespondingSupertypesCache(this))
register(FirDefaultParametersResolver::class, FirDefaultParametersResolver())
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+6 -5
View File
@@ -200,7 +200,7 @@ class FirElementSerializer private constructor(
@OptIn(ExperimentalStdlibApi::class)
private fun FirClass<*>.declarations(): List<FirCallableMemberDeclaration<*>> = buildList {
val memberScope =
defaultType().scope(declarationSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing)
defaultType().scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)
?: error("Null scope for $this")
fun addDeclarationIfNeeded(symbol: FirCallableSymbol<*>) {
@@ -938,6 +938,7 @@ class FirElementSerializer private constructor(
@JvmStatic
fun create(
session: FirSession,
scopeSession: ScopeSession,
klass: FirClass<*>,
extension: FirSerializerExtension,
@@ -946,17 +947,17 @@ class FirElementSerializer private constructor(
): FirElementSerializer {
val parentClassId = klass.symbol.classId.outerClassId
val parent = if (parentClassId != null && !parentClassId.isLocal) {
val parentClass = klass.declarationSiteSession.symbolProvider.getClassLikeSymbolByFqName(parentClassId)!!.fir as FirRegularClass
parentSerializer ?: create(scopeSession, parentClass, extension, null, typeApproximator)
val parentClass = session.symbolProvider.getClassLikeSymbolByFqName(parentClassId)!!.fir as FirRegularClass
parentSerializer ?: create(session, scopeSession, parentClass, extension, null, typeApproximator)
} else {
createTopLevel(klass.declarationSiteSession, scopeSession, extension, typeApproximator)
createTopLevel(session, scopeSession, extension, typeApproximator)
}
// Calculate type parameter ids for the outer class beforehand, as it would've had happened if we were always
// serializing outer classes before nested classes.
// Otherwise our interner can get wrong ids because we may serialize classes in any order.
val serializer = FirElementSerializer(
klass.declarationSiteSession,
session,
scopeSession,
klass,
Interner(parent.typeParameters),
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt
+4 -4
View File
@@ -210,8 +210,8 @@ class FirJvmSerializerExtension(
private fun FirFunction<*>.needsInlineParameterNullCheckRequirement(): Boolean =
this is FirSimpleFunction && isInline && !isSuspend && !isParamAssertionsDisabled &&
!Visibilities.isPrivate(visibility) &&
(valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(declarationSiteSession) } ||
receiverTypeRef?.coneType?.isBuiltinFunctionalType(declarationSiteSession) == true)
(valueParameters.any { it.returnTypeRef.coneType.isBuiltinFunctionalType(session) } ||
receiverTypeRef?.coneType?.isBuiltinFunctionalType(session) == true)
override fun serializeProperty(
property: FirProperty,
@@ -256,7 +256,7 @@ class FirJvmSerializerExtension(
val container =
dispatchReceiverType?.classId?.let {
declarationSiteSession.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
session.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
}
if (container == null || !container.isCompanion) {
return false
@@ -264,7 +264,7 @@ class FirJvmSerializerExtension(
val grandParent =
container.classId.outerClassId?.let {
declarationSiteSession.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
session.firProvider.getFirClassifierByFqName(it) as? FirRegularClass
}
return grandParent != null &&
(grandParent.classKind == ClassKind.INTERFACE || grandParent.classKind == ClassKind.ANNOTATION_CLASS)
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt
+3 -2
View File
@@ -155,17 +155,18 @@ class FirMetadataSerializer(
private val serializer: FirElementSerializer? =
when (val metadata = irClass.metadata) {
is FirMetadataSource.Class -> FirElementSerializer.create(
components.session,
components.scopeSession,
metadata.fir, serializerExtension, (parent as? FirMetadataSerializer)?.serializer, approximator
)
is FirMetadataSource.File -> FirElementSerializer.createTopLevel(
metadata.session,
components.session,
components.scopeSession,
serializerExtension,
approximator
)
is FirMetadataSource.Function -> FirElementSerializer.createForLambda(
metadata.session,
components.session,
components.scopeSession,
serializerExtension,
approximator
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt
+1 -1
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.name.Name
sealed class FirMetadataSource : MetadataSource {
abstract val fir: FirDeclaration
val session: FirSession
val declarationSiteSession: FirSession
get() = fir.declarationSiteSession
override val name: Name?
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt
+1 -1
View File
@@ -470,7 +470,7 @@ class CallAndReferenceGenerator(
val type = typeProjection.typeRef.coneTypeSafe<ConeKotlinType>() ?: continue
map[typeParameter.symbol] = type
}
return ConeSubstitutorByMap(map)
return ConeSubstitutorByMap(map, session)
}
internal fun IrExpression.applyCallArguments(call: FirCall?, annotationMode: Boolean): IrExpression {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt
+12 -12
View File
@@ -63,12 +63,12 @@ class JavaScopeProvider(
}
}
private fun buildDeclaredMemberScope(regularClass: FirRegularClass): FirScope {
return if (regularClass is FirJavaClass) declaredMemberScopeWithLazyNestedScope(
private fun buildDeclaredMemberScope(useSiteSession: FirSession, regularClass: FirRegularClass): FirScope {
return if (regularClass is FirJavaClass) useSiteSession.declaredMemberScopeWithLazyNestedScope(
regularClass,
existingNames = regularClass.existingNestedClassifierNames,
symbolProvider = symbolProvider
) else declaredMemberScope(regularClass)
) else useSiteSession.declaredMemberScope(regularClass)
}
private fun buildUseSiteMemberScopeWithJavaTypes(
@@ -77,7 +77,7 @@ class JavaScopeProvider(
scopeSession: ScopeSession,
): JavaClassUseSiteMemberScope {
return scopeSession.getOrBuild(regularClass.symbol, JAVA_USE_SITE) {
val declaredScope = buildDeclaredMemberScope(regularClass)
val declaredScope = buildDeclaredMemberScope(useSiteSession, regularClass)
val superTypes =
if (regularClass.isThereLoopInSupertypes(useSiteSession))
listOf(StandardClassIds.Any.toConeKotlinType(emptyArray(), isNullable = false))
@@ -122,14 +122,14 @@ class JavaScopeProvider(
if (!visitedClasses.add(klass)) return null
return scopeSession.getOrBuild(klass.symbol, JAVA_ENHANCEMENT_FOR_STATIC) {
val declaredScope = buildDeclaredMemberScope(klass)
val declaredScope = buildDeclaredMemberScope(useSiteSession, klass)
val superClassScope = klass.findJavaSuperClass()?.let {
val superClassScope = klass.findJavaSuperClass(useSiteSession)?.let {
(it.scopeProvider as? JavaScopeProvider)
?.getStaticMemberScopeForCallables(it, useSiteSession, scopeSession, visitedClasses)
} ?: FirTypeScope.Empty
val superTypesScopes = klass.findClosestJavaSuperTypes().mapNotNull {
val superTypesScopes = klass.findClosestJavaSuperTypes(useSiteSession).mapNotNull {
(it.scopeProvider as? JavaScopeProvider)
?.getStaticMemberScopeForCallables(it, useSiteSession, scopeSession, visitedClasses)
}
@@ -149,24 +149,24 @@ class JavaScopeProvider(
}
}
private tailrec fun FirRegularClass.findJavaSuperClass(): FirRegularClass? {
private tailrec fun FirRegularClass.findJavaSuperClass(useSiteSession: FirSession): FirRegularClass? {
val superClass = superConeTypes.firstNotNullResult {
(it.lookupTag.toSymbol(declarationSiteSession)?.fir as? FirRegularClass)?.takeIf { superClass ->
(it.lookupTag.toSymbol(useSiteSession)?.fir as? FirRegularClass)?.takeIf { superClass ->
superClass.classKind == ClassKind.CLASS
}
} ?: return null
if (superClass.origin is FirDeclarationOrigin.Java) return superClass
return superClass.findJavaSuperClass()
return superClass.findJavaSuperClass(useSiteSession)
}
private fun FirRegularClass.findClosestJavaSuperTypes(): Collection<FirRegularClass> {
private fun FirRegularClass.findClosestJavaSuperTypes(useSiteSession: FirSession): Collection<FirRegularClass> {
val result = mutableListOf<FirRegularClass>()
DFS.dfs(listOf(this),
{ regularClass ->
regularClass.superConeTypes.mapNotNull {
it.lookupTag.toSymbol(declarationSiteSession)?.fir as? FirRegularClass
it.lookupTag.toSymbol(useSiteSession)?.fir as? FirRegularClass
}
},
object : DFS.AbstractNodeHandler<FirRegularClass, Unit>() {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt
+2 -2
View File
@@ -213,7 +213,7 @@ class JavaSymbolProvider(
) {
replaceSuperTypeRefs(
javaClass.supertypes.map { supertype ->
supertype.toFirResolvedTypeRef(declarationSiteSession, javaTypeParameterStack, isForSupertypes = true, forTypeParameterBounds = false)
supertype.toFirResolvedTypeRef(session, javaTypeParameterStack, isForSupertypes = true, forTypeParameterBounds = false)
}
)
}
@@ -354,7 +354,7 @@ class JavaSymbolProvider(
valueParametersForAnnotationConstructor.forEach { javaMethod, firValueParameter ->
javaMethod.annotationParameterDefaultValue?.let { javaDefaultValue ->
firValueParameter.defaultValue =
javaDefaultValue.toFirExpression(declarationSiteSession, javaTypeParameterStack, firValueParameter.returnTypeRef)
javaDefaultValue.toFirExpression(session, javaTypeParameterStack, firValueParameter.returnTypeRef)
}
}
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+4 -3
View File
@@ -402,7 +402,7 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound(
} else {
val position = if (isLowerBound) TypeComponentPosition.FLEXIBLE_LOWER else TypeComponentPosition.FLEXIBLE_UPPER
classSymbol?.fir?.createRawArguments(defaultArgs, position) ?: defaultArgs
classSymbol?.fir?.createRawArguments(session, defaultArgs, position) ?: defaultArgs
}
} else {
val typeParameters = runIf(!forTypeParameterBounds && !isForSupertypes) { classSymbol?.fir?.typeParameters } ?: emptyList()
@@ -429,13 +429,14 @@ private fun JavaClassifierType.toConeKotlinTypeForFlexibleBound(
}
private fun FirRegularClass.createRawArguments(
session: FirSession,
defaultArgs: List<ConeStarProjection>,
position: TypeComponentPosition
) = typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
): List<ConeTypeProjection> = typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
val erasedUpperBound = typeParameter.getErasedUpperBound {
defaultType().withArguments(defaultArgs.toTypedArray())
}
computeRawProjection(declarationSiteSession, typeParameter, position, erasedUpperBound)
computeRawProjection(session, typeParameter, position, erasedUpperBound)
}
private fun buildEnumCall(session: FirSession, classId: ClassId?, entryName: Name?) =
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt
+2 -2
View File
@@ -382,13 +382,13 @@ class JavaClassUseSiteMemberScope(
}
private fun FirFunction<*>.computeJvmSignature(): String? {
return computeJvmSignature { it.toConeKotlinTypeProbablyFlexible(declarationSiteSession, typeParameterStack) }
return computeJvmSignature { it.toConeKotlinTypeProbablyFlexible(session, typeParameterStack) }
}
private fun FirFunction<*>.computeJvmDescriptor(customName: String? = null, includeReturnType: Boolean = false): String {
return computeJvmDescriptor(customName, includeReturnType) {
it.toConeKotlinTypeProbablyFlexible(
declarationSiteSession,
session,
typeParameterStack
)
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt
+2 -2
View File
@@ -134,14 +134,14 @@ class JavaOverrideChecker internal constructor(
override fun buildTypeParametersSubstitutorIfCompatible(
overrideCandidate: FirCallableMemberDeclaration<*>,
baseDeclaration: FirCallableMemberDeclaration<*>
): ConeSubstitutor? {
): ConeSubstitutor {
if (!overrideCandidate.isTypeParameterDependent() && !baseDeclaration.isTypeParameterDependent()) {
return ConeSubstitutor.Empty
}
val typeParameters = linkedSetOf<FirTypeParameterRef>()
overrideCandidate.extractTypeParametersTo(typeParameters)
baseDeclaration.extractTypeParametersTo(typeParameters)
return substitutorByMap(typeParameters.buildErasure())
return substitutorByMap(typeParameters.buildErasure(), session)
}
override fun isOverriddenFunction(overrideCandidate: FirSimpleFunction, baseDeclaration: FirSimpleFunction): Boolean {
compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt
+2 -1
View File
@@ -35,7 +35,8 @@ class JvmMappedScope(
private val substitutor = ConeSubstitutorByMap(
firJavaClass.typeParameters.zip(firKotlinClass.typeParameters).map { (javaParameter, kotlinParameter) ->
javaParameter.symbol to ConeTypeParameterTypeImpl(ConeTypeParameterLookupTag(kotlinParameter.symbol), isNullable = false)
}.toMap()
}.toMap(),
session
)
private val kotlinDispatchReceiverType = firKotlinClass.defaultType()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt
+38 -40
View File
@@ -359,51 +359,49 @@ private fun initialTypeOfCandidate(candidate: Candidate, typeRef: FirResolvedTyp
return candidate.substitutor.substituteOrSelf(typeRef.type)
}
inline val FirCallableDeclaration<*>.containingClass: FirRegularClass?
get() = this.containingClassAttr?.let { lookupTag ->
declarationSiteSession.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
}
fun FirCallableDeclaration<*>.getContainingClass(session: FirSession): FirRegularClass? = this.containingClassAttr?.let { lookupTag ->
session.symbolProvider.getSymbolByLookupTag(lookupTag)?.fir as? FirRegularClass
}
val FirFunction<*>.asForbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget?
get() {
if (this is FirConstructor && this.isPrimary) {
this.containingClass?.let { containingClass ->
if (containingClass.classKind == ClassKind.ANNOTATION_CLASS) {
// Java annotation classes allow (actually require) named parameters.
return null
}
fun FirFunction<*>.getAsForbiddenNamedArgumentsTarget(session: FirSession): ForbiddenNamedArgumentsTarget? {
if (this is FirConstructor && this.isPrimary) {
this.getContainingClass(session)?.let { containingClass ->
if (containingClass.classKind == ClassKind.ANNOTATION_CLASS) {
// Java annotation classes allow (actually require) named parameters.
return null
}
}
if (this is FirMemberDeclaration && status.isExpect) {
return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
}
return when (origin) {
FirDeclarationOrigin.Source, FirDeclarationOrigin.Library -> null
FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.asForbiddenNamedArgumentsTarget
FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.asForbiddenNamedArgumentsTarget
// For intersection overrides, the logic in
// org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope#selectMostSpecificMember picks the most specific one and store
// it in originalForIntersectionOverrideAttr. This follows from FE1.0 behavior which selects the most specific function
// (org.jetbrains.kotlin.resolve.OverridingUtil#selectMostSpecificMember), from which the `hasStableParameterNames` status is
// copied.
FirDeclarationOrigin.IntersectionOverride -> originalForIntersectionOverrideAttr?.asForbiddenNamedArgumentsTarget
FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> ForbiddenNamedArgumentsTarget.NON_KOTLIN_FUNCTION
FirDeclarationOrigin.SamConstructor -> null
FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.asForbiddenNamedArgumentsTarget
// referenced function of a Kotlin function type
FirDeclarationOrigin.BuiltIns -> {
if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) {
ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
} else {
null
}
}
FirDeclarationOrigin.Synthetic -> null
is FirDeclarationOrigin.Plugin -> null // TODO: figure out what to do with plugin generated functions
}
}
if (this is FirMemberDeclaration && status.isExpect) {
return ForbiddenNamedArgumentsTarget.EXPECTED_CLASS_MEMBER
}
return when (origin) {
FirDeclarationOrigin.Source, FirDeclarationOrigin.Library -> null
FirDeclarationOrigin.Delegated -> delegatedWrapperData?.wrapped?.getAsForbiddenNamedArgumentsTarget(session)
FirDeclarationOrigin.ImportedFromObject -> importedFromObjectData?.original?.getAsForbiddenNamedArgumentsTarget(session)
// For intersection overrides, the logic in
// org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope#selectMostSpecificMember picks the most specific one and store
// it in originalForIntersectionOverrideAttr. This follows from FE1.0 behavior which selects the most specific function
// (org.jetbrains.kotlin.resolve.OverridingUtil#selectMostSpecificMember), from which the `hasStableParameterNames` status is
// copied.
FirDeclarationOrigin.IntersectionOverride -> originalForIntersectionOverrideAttr?.getAsForbiddenNamedArgumentsTarget(session)
FirDeclarationOrigin.Java, FirDeclarationOrigin.Enhancement -> ForbiddenNamedArgumentsTarget.NON_KOTLIN_FUNCTION
FirDeclarationOrigin.SamConstructor -> null
FirDeclarationOrigin.SubstitutionOverride -> originalForSubstitutionOverrideAttr?.getAsForbiddenNamedArgumentsTarget(session)
// referenced function of a Kotlin function type
FirDeclarationOrigin.BuiltIns -> {
if (dispatchReceiverClassOrNull()?.isBuiltinFunctionalType() == true) {
ForbiddenNamedArgumentsTarget.INVOKE_ON_FUNCTION_TYPE
} else {
null
}
}
FirDeclarationOrigin.Synthetic -> null
is FirDeclarationOrigin.Plugin -> null // TODO: figure out what to do with plugin generated functions
}
}
// TODO: handle functions with non-stable parameter names, see also
// org.jetbrains.kotlin.fir.serialization.FirElementSerializer.functionProto
// org.jetbrains.kotlin.fir.serialization.FirElementSerializer.constructorProto
inline val FirFunction<*>.hasStableParameterNames: Boolean get() = asForbiddenNamedArgumentsTarget == null
fun FirFunction<*>.getHasStableParameterNames(session: FirSession): Boolean = getAsForbiddenNamedArgumentsTarget(session) == null
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt
+2
View File
@@ -94,6 +94,7 @@ class FirSamResolverImpl(
Pair(parameterSymbol, typeArgument)
}
.toMap(),
firSession
)
val result =
@@ -148,6 +149,7 @@ class FirSamResolverImpl(
firRegularClass.typeParameters
.map { it.symbol }
.zip(newTypeParameterTypes).toMap(),
firSession
)
for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(firRegularClass.typeParameters)) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt
+1 -1
View File
@@ -47,7 +47,7 @@ private fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: Scope
val substitution = createSubstitution(fir.typeParameters, fullyExpandedType, useSiteSession)
fir.scopeForClass(substitutorByMap(substitution), useSiteSession, scopeSession)
fir.scopeForClass(substitutorByMap(substitution, useSiteSession), useSiteSession, scopeSession)
}
is ConeTypeParameterType -> {
val symbol = lookupTag.symbol
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt
+2 -2
View File
@@ -143,9 +143,9 @@ fun ConeClassLikeType.wrapSubstitutionScopeIfNeed(
// to determine parameter types properly (e.g. String, String instead of K, V)
val platformTypeParameters = platformClass.typeParameters
val platformSubstitution = createSubstitution(platformTypeParameters, this, session)
substitutorByMap(originalSubstitution + platformSubstitution)
substitutorByMap(originalSubstitution + platformSubstitution, session)
} else {
substitutorByMap(originalSubstitution)
substitutorByMap(originalSubstitution, session)
}
FirClassSubstitutionScope(
session, useSiteMemberScope, substitutor,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt
+1 -1
View File
@@ -178,6 +178,6 @@ abstract class AbstractConeCallConflictResolver(
}
private fun createEmptyConstraintSystem(): SimpleConstraintSystem {
return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem())
return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem(), inferenceComponents.session)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt
+3 -2
View File
@@ -6,6 +6,7 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.modality
import org.jetbrains.kotlin.fir.render
@@ -196,7 +197,7 @@ class ConeOverloadConflictResolver(
object NoSubstitutor : TypeSubstitutorMarker
class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl) : SimpleConstraintSystem {
class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl, val session: FirSession) : SimpleConstraintSystem {
override fun registerTypeVariables(typeParameters: Collection<TypeParameterMarker>): TypeSubstitutorMarker = with(context) {
val csBuilder = system.getBuilder()
val substitutionMap = typeParameters.associateBy({ (it as ConeTypeParameterLookupTag).typeParameterSymbol }) {
@@ -206,7 +207,7 @@ class ConeSimpleConstraintSystemImpl(val system: NewConstraintSystemImpl) : Simp
variable.defaultType
}
val substitutor = substitutorByMap(substitutionMap)
val substitutor = substitutorByMap(substitutionMap, session)
for (typeParameter in typeParameters) {
require(typeParameter is ConeTypeParameterLookupTag)
for (upperBound in typeParameter.symbol.fir.bounds) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt
+1 -1
View File
@@ -156,7 +156,7 @@ private fun prepareSubstitutorForTypeAliasConstructors(
it as? ConeKotlinType ?: return null
}
return substitutorByMap(
expandedClass.typeParameters.map { it.symbol }.zip(resultingTypeArguments).toMap()
expandedClass.typeParameters.map { it.symbol }.zip(resultingTypeArguments).toMap(), session
)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt
+5 -3
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
import org.jetbrains.kotlin.fir.renderWithType
@@ -31,7 +32,7 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
}
val csBuilder = candidate.system.getBuilder()
val (substitutor, freshVariables) =
createToFreshVariableSubstitutorAndAddInitialConstraints(declaration, csBuilder)
createToFreshVariableSubstitutorAndAddInitialConstraints(declaration, csBuilder, context.session)
candidate.substitutor = substitutor
candidate.freshVariables = freshVariables
@@ -110,14 +111,15 @@ internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
private fun createToFreshVariableSubstitutorAndAddInitialConstraints(
declaration: FirTypeParameterRefsOwner,
csBuilder: ConstraintSystemOperation
csBuilder: ConstraintSystemOperation,
session: FirSession
): Pair<ConeSubstitutor, List<ConeTypeVariable>> {
val typeParameters = declaration.typeParameters
val freshTypeVariables = typeParameters.map { ConeTypeParameterBasedTypeVariable(it.symbol) }
val toFreshVariables = substitutorByMap(freshTypeVariables.associate { it.typeParameterSymbol to it.defaultType })
val toFreshVariables = substitutorByMap(freshTypeVariables.associate { it.typeParameterSymbol to it.defaultType }, session)
for (freshVariable in freshTypeVariables) {
csBuilder.registerVariable(freshVariable)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt
+5 -3
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
import org.jetbrains.kotlin.fir.declarations.FirFunction
import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
@@ -16,7 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildNamedArgumentExpression
import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
import org.jetbrains.kotlin.fir.resolve.asForbiddenNamedArgumentsTarget
import org.jetbrains.kotlin.fir.resolve.getAsForbiddenNamedArgumentsTarget
import org.jetbrains.kotlin.fir.resolve.defaultParameterResolver
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.name.Name
@@ -85,7 +86,7 @@ fun BodyResolveComponents.mapArguments(
}
}
val processor = FirCallArgumentsProcessor(function, this, originScope)
val processor = FirCallArgumentsProcessor(session, function, this, originScope)
processor.processArgumentsInParenthesis(argumentsInParenthesis)
if (externalArgument != null) {
processor.processExternalArgument(externalArgument)
@@ -96,6 +97,7 @@ fun BodyResolveComponents.mapArguments(
}
private class FirCallArgumentsProcessor(
private val useSiteSession: FirSession,
private val function: FirFunction<*>,
private val bodyResolveComponents: BodyResolveComponents,
private val originScope: FirScope?,
@@ -109,7 +111,7 @@ private class FirCallArgumentsProcessor(
val result: LinkedHashMap<FirValueParameter, ResolvedCallArgument> = LinkedHashMap(function.valueParameters.size)
val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget? by lazy {
function.asForbiddenNamedArgumentsTarget
function.getAsForbiddenNamedArgumentsTarget(useSiteSession)
}
private enum class State {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt
+1 -1
View File
@@ -195,7 +195,7 @@ internal object CheckVisibility : CheckerStage() {
if (declaration is FirConstructor) {
// TODO: Should be some other form
val classSymbol = declaration.returnTypeRef.coneTypeUnsafe<ConeClassLikeType>().lookupTag.toSymbol(declaration.declarationSiteSession)
val classSymbol = declaration.returnTypeRef.coneTypeUnsafe<ConeClassLikeType>().lookupTag.toSymbol(context.session)
if (classSymbol is FirRegularClassSymbol) {
if (classSymbol.fir.classKind.isSingleton) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt
+1 -1
View File
@@ -875,7 +875,7 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
val substitutionFromArguments = typeParameters.zip(qualifiedAccess.typeArguments).map { (typeParameterRef, typeArgument) ->
typeParameterRef.symbol to typeArgument.toConeTypeProjection().type
}.filter { it.second != null }.toMap() as Map<FirTypeParameterSymbol, ConeKotlinType>
ConeSubstitutorByMap(substitutionFromArguments)
ConeSubstitutorByMap(substitutionFromArguments, components.session)
} else {
ConeSubstitutor.Empty
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt
+1 -1
View File
@@ -77,7 +77,7 @@ private fun extraLambdaInfo(
?: expectedType?.typeArguments?.singleOrNull()?.safeAs<ConeKotlinTypeProjection>()?.type?.takeIf { isFunctionSupertype }
?: typeVariable.defaultType
val nothingType = argument.declarationSiteSession.builtinTypes.nothingType.type
val nothingType = session.builtinTypes.nothingType.type
val parameters = argument.valueParameters.map {
it.returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: nothingType
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt
+1 -1
View File
@@ -53,7 +53,7 @@ abstract class FirSymbolProvider(val session: FirSession) : FirSessionComponent
fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Name): List<FirVariableSymbol<*>> {
val classSymbol = getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: return emptyList()
val declaredMemberScope = declaredMemberScope(classSymbol.fir)
val declaredMemberScope = session.declaredMemberScope(classSymbol.fir)
val result = mutableListOf<FirVariableSymbol<*>>()
declaredMemberScope.processPropertiesByName(name, result::add)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt
+9 -6
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.resolve.substitution
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.fir.types.*
@@ -130,13 +131,13 @@ abstract class AbstractConeSubstitutor : ConeSubstitutor() {
}
fun substitutorByMap(substitution: Map<FirTypeParameterSymbol, ConeKotlinType>): ConeSubstitutor {
fun substitutorByMap(substitution: Map<FirTypeParameterSymbol, ConeKotlinType>, useSiteSession: FirSession): ConeSubstitutor {
// If all arguments match parameters, then substitutor isn't needed
if (substitution.all { (parameterSymbol, argumentType) ->
(argumentType as? ConeTypeParameterType)?.lookupTag?.typeParameterSymbol == parameterSymbol
}
) return ConeSubstitutor.Empty
return ConeSubstitutorByMap(substitution)
return ConeSubstitutorByMap(substitution, useSiteSession)
}
data class ChainedSubstitutor(private val first: ConeSubstitutor, private val second: ConeSubstitutor) : ConeSubstitutor() {
@@ -152,13 +153,15 @@ fun ConeSubstitutor.chain(other: ConeSubstitutor): ConeSubstitutor {
return ChainedSubstitutor(this, other)
}
data class ConeSubstitutorByMap(val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>) : AbstractConeSubstitutor() {
data class ConeSubstitutorByMap(
val substitution: Map<FirTypeParameterSymbol, ConeKotlinType>,
val useSiteSession: FirSession
) : AbstractConeSubstitutor() {
override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
if (type !is ConeTypeParameterType) return null
val result = substitution[type.lookupTag.symbol].updateNullabilityIfNeeded(type) ?: return null
val session = type.lookupTag.symbol.fir.declarationSiteSession
if (type.isUnsafeVarianceType(session)) {
return session.inferenceComponents.approximator.approximateToSuperType(
if (type.isUnsafeVarianceType(useSiteSession)) {
return useSiteSession.inferenceComponents.approximator.approximateToSuperType(
result, TypeApproximatorConfiguration.FinalApproximationAfterResolutionAndInference
) ?: result
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt
+3 -3
View File
@@ -75,11 +75,11 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
firClass.addTypeParametersScope()
val companionObject = firClass.companionObject
if (companionObject != null) {
nestedClassifierScope(companionObject)?.let(scopes::add)
session.nestedClassifierScope(companionObject)?.let(scopes::add)
}
}
nestedClassifierScope(firClass)?.let(scopes::add)
session.nestedClassifierScope(firClass)?.let(scopes::add)
// Note that annotations are still visited here
// again, although there's no need in it
@@ -100,5 +100,5 @@ fun createSubstitutionForSupertype(superType: ConeLookupTagBasedType, session: F
it as? ConeKotlinType ?: ConeClassErrorType(ConeSimpleDiagnostic("illegal projection usage", DiagnosticKind.IllegalProjectionUsage))
}
val mapping = klass.typeParameters.map { it.symbol }.zip(arguments).toMap()
return ConeSubstitutorByMap(mapping)
return ConeSubstitutorByMap(mapping, session)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt
+4 -4
View File
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirStatement
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.firProvider
import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.symbolProvider
@@ -30,11 +29,12 @@ class FirSealedClassInheritorsProcessor(
) : FirGlobalResolveProcessor(session, scopeSession) {
override fun process(files: Collection<FirFile>) {
val sealedClassInheritorsMap = mutableMapOf<FirRegularClass, MutableList<ClassId>>()
files.forEach { it.accept(InheritorsCollector, sealedClassInheritorsMap) }
val inheritorsCollector = InheritorsCollector(session)
files.forEach { it.accept(inheritorsCollector, sealedClassInheritorsMap) }
files.forEach { it.transformSingle(InheritorsTransformer(sealedClassInheritorsMap), null) }
}
object InheritorsCollector : FirDefaultVisitor<Unit, MutableMap<FirRegularClass, MutableList<ClassId>>>() {
class InheritorsCollector(val session: FirSession) : FirDefaultVisitor<Unit, MutableMap<FirRegularClass, MutableList<ClassId>>>() {
override fun visitElement(element: FirElement, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {}
override fun visitFile(file: FirFile, data: MutableMap<FirRegularClass, MutableList<ClassId>>) {
@@ -48,7 +48,7 @@ class FirSealedClassInheritorsProcessor(
data.computeIfAbsent(regularClass) { mutableListOf() }
}
val symbolProvider = regularClass.declarationSiteSession.symbolProvider
val symbolProvider = session.symbolProvider
for (typeRef in regularClass.superTypeRefs) {
val parent = extractClassFromTypeRef(symbolProvider, typeRef).takeIf { it?.modality == Modality.SEALED } ?: continue
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt
+1 -1
View File
@@ -390,7 +390,7 @@ abstract class AbstractFirStatusResolveTransformer(
return
}
if (regularClass.resolvePhase > FirResolvePhase.STATUS) return
val firProvider = regularClass.declarationSiteSession.firProvider
val firProvider = session.firProvider
val statusComputationStatus = statusComputationSession[regularClass]
if (!statusComputationStatus.requiresComputation) return
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
+2 -2
View File
@@ -160,9 +160,9 @@ private fun createScopesForNestedClasses(
addIfNotNull(klass.typeParametersScope())
val companionObjects = klass.declarations.filterIsInstance<FirRegularClass>().filter { it.isCompanion }
for (companionObject in companionObjects) {
addIfNotNull(nestedClassifierScope(companionObject))
addIfNotNull(session.nestedClassifierScope(companionObject))
}
addIfNotNull(nestedClassifierScope(klass))
addIfNotNull(session.nestedClassifierScope(klass))
}
fun FirRegularClass.resolveSupertypesInTheAir(session: FirSession): List<FirTypeRef> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt
+1 -1
View File
@@ -43,7 +43,7 @@ class FirPluginAnnotationsResolveTransformer(
override fun transformFile(file: FirFile, data: Any?): FirFile {
checkSessionConsistency(file)
if (!extensionService.hasPredicateBasedExtensions) return file
val registeredPluginAnnotations = file.declarationSiteSession.registeredPluginAnnotations
val registeredPluginAnnotations = session.registeredPluginAnnotations
file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS)
val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations)
if (!newAnnotations.isEmpty) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt
+4 -4
View File
@@ -32,7 +32,7 @@ class KotlinScopeProvider(
scopeSession: ScopeSession
): FirTypeScope {
return scopeSession.getOrBuild(klass.symbol, USE_SITE) {
val declaredScope = declaredMemberScope(klass)
val declaredScope = useSiteSession.declaredMemberScope(klass)
val decoratedDeclaredMemberScope =
declaredMemberScopeDecorator(klass, declaredScope, useSiteSession, scopeSession)
@@ -58,13 +58,13 @@ class KotlinScopeProvider(
scopeSession: ScopeSession
): FirScope? {
return when (klass.classKind) {
ClassKind.ENUM_CLASS -> FirOnlyCallablesScope(FirStaticScope(declaredMemberScope(klass)))
ClassKind.ENUM_CLASS -> FirOnlyCallablesScope(FirStaticScope(useSiteSession.declaredMemberScope(klass)))
else -> null
}
}
override fun getNestedClassifierScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? {
return nestedClassifierScope(klass)
return useSiteSession.nestedClassifierScope(klass)
}
}
@@ -125,7 +125,7 @@ fun ConeKotlinType.scopeForSupertype(
private fun substitutor(symbol: FirRegularClassSymbol, type: ConeClassLikeType, useSiteSession: FirSession): ConeSubstitutor {
if (type.typeArguments.isEmpty()) return ConeSubstitutor.Empty
val originalSubstitution = createSubstitution(symbol.fir.typeParameters, type, useSiteSession)
return substitutorByMap(originalSubstitution)
return substitutorByMap(originalSubstitution, useSiteSession)
}
fun FirClass<*>.scopeForSupertype(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt
+4 -2
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
@@ -22,7 +23,8 @@ abstract class FirAbstractOverrideChecker : FirOverrideChecker {
fun buildSubstitutorForOverridesCheck(
overrideCandidate: FirCallableMemberDeclaration<*>,
baseDeclaration: FirCallableMemberDeclaration<*>
baseDeclaration: FirCallableMemberDeclaration<*>,
useSiteSession: FirSession
): ConeSubstitutor? {
if (overrideCandidate.typeParameters.size != baseDeclaration.typeParameters.size) return null
@@ -30,5 +32,5 @@ fun buildSubstitutorForOverridesCheck(
val types = baseDeclaration.typeParameters.map {
ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), false)
}
return substitutorByMap(overrideCandidate.typeParameters.map { it.symbol }.zip(types).toMap())
return substitutorByMap(overrideCandidate.typeParameters.map { it.symbol }.zip(types).toMap(), useSiteSession)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt
+4 -2
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -16,6 +17,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.name.Name
class FirClassDeclaredMemberScope(
val useSiteSession: FirSession,
klass: FirClass<*>,
useLazyNestedClassifierScope: Boolean = false,
existingNames: List<Name>? = null,
@@ -24,7 +26,7 @@ class FirClassDeclaredMemberScope(
private val nestedClassifierScope: FirScope? = if (useLazyNestedClassifierScope) {
lazyNestedClassifierScope(klass.symbol.classId, existingNames!!, symbolProvider!!)
} else {
nestedClassifierScope(klass)
useSiteSession.nestedClassifierScope(klass)
}
private val callablesIndex: Map<Name, List<FirCallableSymbol<*>>> = run {
@@ -65,7 +67,7 @@ class FirClassDeclaredMemberScope(
val symbols = callablesIndex[name] ?: emptyList()
for (symbol in symbols) {
if (symbol is D) {
symbol.ensureResolvedForCalls(symbol.fir.declarationSiteSession)
symbol.ensureResolvedForCalls(useSiteSession)
processor(symbol)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt
+1
View File
@@ -204,6 +204,7 @@ class FirClassSubstitutionScope(
private fun createSubstitutedData(member: FirCallableMemberDeclaration<*>): SubstitutedData {
val (newTypeParameters, substitutor) = FirFakeOverrideGenerator.createNewTypeParametersAndSubstitutor(
session,
member as FirTypeParameterRefsOwner,
substitutor,
forceTypeParametersRecreation = dispatchReceiverTypeForSubstitutedMembers.lookupTag != member.dispatchReceiverClassOrNull()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt
+10 -15
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSessionComponent
import org.jetbrains.kotlin.fir.ThreadSafeMutableState
import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -17,7 +18,7 @@ import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.utils.getOrPutNullable
@ThreadSafeMutableState
class FirDeclaredMemberScopeProvider : FirSessionComponent {
class FirDeclaredMemberScopeProvider(val useSiteSession: FirSession) : FirSessionComponent {
private val declaredMemberCache = mutableMapOf<FirClass<*>, FirClassDeclaredMemberScope>()
private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope?>()
@@ -46,39 +47,33 @@ class FirDeclaredMemberScopeProvider : FirSessionComponent {
symbolProvider: FirSymbolProvider?
): FirClassDeclaredMemberScope {
return declaredMemberCache.getOrPut(klass) {
FirClassDeclaredMemberScope(klass, useLazyNestedClassifierScope, existingNames, symbolProvider)
FirClassDeclaredMemberScope(useSiteSession, klass, useLazyNestedClassifierScope, existingNames, symbolProvider)
}
}
fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
return nestedClassifierCache.getOrPutNullable(klass) {
FirNestedClassifierScope(klass).takeUnless { it.isEmpty() }
FirNestedClassifierScope(klass, useSiteSession).takeUnless { it.isEmpty() }
}
}
}
fun declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
return klass
.declarationSiteSession
.declaredMemberScopeProvider
fun FirSession.declaredMemberScope(klass: FirClass<*>): FirClassDeclaredMemberScope {
return declaredMemberScopeProvider
.declaredMemberScope(klass, useLazyNestedClassifierScope = false, existingNames = null, symbolProvider = null)
}
fun declaredMemberScopeWithLazyNestedScope(
fun FirSession.declaredMemberScopeWithLazyNestedScope(
klass: FirClass<*>,
existingNames: List<Name>,
symbolProvider: FirSymbolProvider
): FirScope {
return klass
.declarationSiteSession
.declaredMemberScopeProvider
return declaredMemberScopeProvider
.declaredMemberScope(klass, useLazyNestedClassifierScope = true, existingNames = existingNames, symbolProvider = symbolProvider)
}
fun nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
return klass
.declarationSiteSession
.declaredMemberScopeProvider
fun FirSession.nestedClassifierScope(klass: FirClass<*>): FirNestedClassifierScope? {
return declaredMemberScopeProvider
.nestedClassifierScope(klass)
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt
+9 -5
View File
@@ -111,7 +111,7 @@ object FirFakeOverrideGenerator {
dispatchReceiverType = newDispatchReceiverType
attributes = baseFunction.attributes.copy()
typeParameters += configureAnnotationsTypeParametersAndSignature(
baseFunction, newParameterTypes, newTypeParameters, newReceiverType, newReturnType, fakeOverrideSubstitution
session, baseFunction, newParameterTypes, newTypeParameters, newReceiverType, newReturnType, fakeOverrideSubstitution
).filterIsInstance<FirTypeParameter>()
}
}
@@ -137,7 +137,7 @@ object FirFakeOverrideGenerator {
symbol = fakeOverrideSymbol
typeParameters += configureAnnotationsTypeParametersAndSignature(
baseConstructor, newParameterTypes, newTypeParameters, newReceiverType = null, newReturnType, fakeOverrideSubstitution
session, baseConstructor, newParameterTypes, newTypeParameters, newReceiverType = null, newReturnType, fakeOverrideSubstitution
)
dispatchReceiverType = newDispatchReceiverType
@@ -151,6 +151,7 @@ object FirFakeOverrideGenerator {
}
private fun FirFunctionBuilder.configureAnnotationsTypeParametersAndSignature(
useSiteSession: FirSession,
baseFunction: FirFunction<*>,
newParameterTypes: List<ConeKotlinType?>?,
newTypeParameters: List<FirTypeParameterRef>?,
@@ -171,7 +172,7 @@ object FirFakeOverrideGenerator {
}
newTypeParameters == null -> {
val (copiedTypeParameters, substitutor) = createNewTypeParametersAndSubstitutor(
baseFunction, ConeSubstitutor.Empty
useSiteSession, baseFunction, ConeSubstitutor.Empty
)
val copiedParameterTypes = baseFunction.valueParameters.map {
substitutor.substituteOrNull(it.returnTypeRef.coneType)
@@ -294,6 +295,7 @@ object FirFakeOverrideGenerator {
dispatchReceiverType = newDispatchReceiverType
attributes = baseProperty.attributes.copy()
typeParameters += configureAnnotationsTypeParametersAndSignature(
session,
baseProperty,
newTypeParameters,
newReceiverType,
@@ -304,6 +306,7 @@ object FirFakeOverrideGenerator {
}
private fun FirPropertyBuilder.configureAnnotationsTypeParametersAndSignature(
useSiteSession: FirSession,
baseProperty: FirProperty,
newTypeParameters: List<FirTypeParameter>?,
newReceiverType: ConeKotlinType?,
@@ -317,7 +320,7 @@ object FirFakeOverrideGenerator {
}
newTypeParameters == null -> {
val (copiedTypeParameters, substitutor) = createNewTypeParametersAndSubstitutor(
baseProperty, ConeSubstitutor.Empty
useSiteSession, baseProperty, ConeSubstitutor.Empty
)
val (copiedReceiverType, possibleReturnType) = substituteReceiverAndReturnType(
baseProperty, newReceiverType, newReturnType, substitutor
@@ -456,6 +459,7 @@ object FirFakeOverrideGenerator {
// Returns a list of type parameters, and a substitutor that should be used for all other types
fun createNewTypeParametersAndSubstitutor(
useSiteSession: FirSession,
member: FirTypeParameterRefsOwner,
substitutor: ConeSubstitutor,
forceTypeParametersRecreation: Boolean = true
@@ -481,7 +485,7 @@ object FirFakeOverrideGenerator {
else null
}.toMap()
val additionalSubstitutor = substitutorByMap(substitutionMapForNewParameters)
val additionalSubstitutor = substitutorByMap(substitutionMapForNewParameters, useSiteSession)
var wereChangesInTypeParameters = forceTypeParametersRecreation
for ((newTypeParameter, oldTypeParameter) in newTypeParameters.zip(member.typeParameters)) {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt
+3 -2
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
@@ -19,7 +20,7 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
import org.jetbrains.kotlin.name.Name
class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope(), FirContainingNamesAwareScope {
class FirNestedClassifierScope(val klass: FirClass<*>, val useSiteSession: FirSession) : FirScope(), FirContainingNamesAwareScope {
private val classIndex: Map<Name, FirRegularClassSymbol> = run {
val result = mutableMapOf<Name, FirRegularClassSymbol>()
for (declaration in klass.declarations) {
@@ -40,7 +41,7 @@ class FirNestedClassifierScope(val klass: FirClass<*>) : FirScope(), FirContaini
val substitution = klass.typeParameters.associate {
it.symbol to it.toConeType()
}
processor(matchedClass, ConeSubstitutorByMap(substitution))
processor(matchedClass, ConeSubstitutorByMap(substitution, useSiteSession))
}
override fun getClassifierNames(): Set<Name> = classIndex.keys
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt
+1 -1
View File
@@ -97,7 +97,7 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO
overrideCandidate: FirCallableMemberDeclaration<*>,
baseDeclaration: FirCallableMemberDeclaration<*>
): ConeSubstitutor? {
val substitutor = buildSubstitutorForOverridesCheck(overrideCandidate, baseDeclaration) ?: return null
val substitutor = buildSubstitutorForOverridesCheck(overrideCandidate, baseDeclaration, session) ?: return null
if (
overrideCandidate.typeParameters.isNotEmpty() &&
overrideCandidate.typeParameters.zip(baseDeclaration.typeParameters).any { (override, base) ->
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt
+1 -1
View File
@@ -396,7 +396,7 @@ class FirTypeIntersectionScope private constructor(
val bFir = b.fir
if (aFir !is FirCallableMemberDeclaration<*> || bFir !is FirCallableMemberDeclaration<*>) return false
val substitutor = buildSubstitutorForOverridesCheck(aFir, bFir) ?: return false
val substitutor = buildSubstitutorForOverridesCheck(aFir, bFir, session) ?: return false
// NB: these lines throw CCE in modularized tests when changed to just .coneType (FirImplicitTypeRef)
val aReturnType = a.fir.returnTypeRef.coneTypeSafe<ConeKotlinType>()?.let(substitutor::substituteOrSelf) ?: return false
val bReturnType = b.fir.returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: return false
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt
+1 -1
View File
@@ -565,7 +565,7 @@ class ConeTypeCheckerContext(
parameter.symbol to ((argument as? ConeKotlinTypeProjection)?.type
?: session.builtinTypes.nullableAnyType.type)//StandardClassIds.Any(session.firSymbolProvider).constructType(emptyArray(), isNullable = true))
}
substitutorByMap(substitution)
substitutorByMap(substitution, session)
} else {
ConeSubstitutor.Empty
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt
+3 -2
View File
@@ -344,9 +344,10 @@ private fun ConeTypeContext.captureArguments(type: ConeKotlinType, status: Captu
ConeCapturedType(status, lowerType, argument, typeConstructor.getParameter(index))
}
val substitutor = substitutorByMap((0 until argumentsCount).map { index ->
val substitution = (0 until argumentsCount).map { index ->
(typeConstructor.getParameter(index) as ConeTypeParameterLookupTag).symbol to (newArguments[index] as ConeKotlinType)
}.toMap())
}.toMap()
val substitutor = substitutorByMap(substitution, session)
for (index in 0 until argumentsCount) {
val oldArgument = type.typeArguments[index]
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt
+1 -1
View File
@@ -91,7 +91,7 @@ internal class KtFirScopeProvider(
override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtDeclaredMemberScope = withValidityAssertion {
declaredMemberScopeCache.getOrPut(classSymbol) {
val firScope = classSymbol.withFirForScope {
declaredMemberScope(it)
analysisSession.rootModuleSession.declaredMemberScope(it)
} ?: return@getOrPut KtFirEmptyMemberScope(classSymbol)
firScopeStorage.register(firScope)