From 234ab3b35d0a4e45162d5075c5bc2fcb56b22b71 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 21 Apr 2021 13:26:40 +0300 Subject: [PATCH] [FIR] Fix all illegal usages of declarationSiteSession in compiler There are still some usages in IDE which should be investigated --- .../analysis/cfa/FirCallsEffectAnalyzer.kt | 5 +- .../analysis/cfa/FirReturnsImpliesAnalyzer.kt | 12 ++- .../fir/analysis/checkers/FirHelpers.kt | 40 +--------- .../FirExposedVisibilityDeclarationChecker.kt | 2 +- .../FirInlineClassDeclarationChecker.kt | 4 +- .../declaration/FirOverrideChecker.kt | 5 +- .../expression/FirCallableReferenceChecker.kt | 4 +- .../expression/FirNotASupertypeChecker.kt | 2 +- ...upertypeExtendedByOtherSupertypeChecker.kt | 2 +- .../FirUpperBoundViolatedChecker.kt | 9 ++- .../fir/session/ComponentsContainers.kt | 2 +- .../fir/serialization/FirElementSerializer.kt | 11 +-- .../backend/jvm/FirJvmSerializerExtension.kt | 8 +- .../fir/backend/jvm/FirMetadataSerializer.kt | 5 +- .../kotlin/fir/backend/FirMetadataSource.kt | 2 +- .../generators/CallAndReferenceGenerator.kt | 2 +- .../kotlin/fir/java/JavaScopeProvider.kt | 24 +++--- .../kotlin/fir/java/JavaSymbolProvider.kt | 4 +- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 7 +- .../scopes/JavaClassUseSiteMemberScope.kt | 4 +- .../fir/java/scopes/JavaOverrideChecker.kt | 4 +- .../kotlin/fir/scopes/jvm/JvmMappedScope.kt | 3 +- .../kotlin/fir/resolve/ResolveUtils.kt | 78 +++++++++---------- .../kotlin/fir/resolve/SamResolution.kt | 2 + .../kotlin/fir/resolve/ScopeUtils.kt | 2 +- .../kotlin/fir/resolve/SupertypeUtils.kt | 4 +- .../calls/AbstractConeCallConflictResolver.kt | 2 +- .../calls/ConeOverloadConflictResolver.kt | 5 +- .../resolve/calls/ConstructorProcessing.kt | 2 +- ...CreateFreshTypeVariableSubstitutorStage.kt | 8 +- .../calls/FirArgumentsToParametersMapper.kt | 8 +- .../fir/resolve/calls/ResolutionStages.kt | 2 +- .../fir/resolve/dfa/FirDataFlowAnalyzer.kt | 2 +- .../resolve/inference/PostponedArguments.kt | 2 +- .../resolve/providers/FirSymbolProvider.kt | 2 +- .../fir/resolve/substitution/Substitutors.kt | 15 ++-- ...irAbstractTreeTransformerWithSuperTypes.kt | 6 +- .../FirSealedClassInheritorsProcessor.kt | 8 +- .../FirStatusResolveTransformer.kt | 2 +- .../transformers/FirSupertypesResolution.kt | 4 +- .../FirPluginAnnotationsResolveTransformer.kt | 2 +- .../kotlin/fir/scopes/KotlinScopeProvider.kt | 8 +- .../scopes/impl/FirAbstractOverrideChecker.kt | 6 +- .../impl/FirClassDeclaredMemberScope.kt | 6 +- .../scopes/impl/FirClassSubstitutionScope.kt | 1 + .../impl/FirDeclaredMemberScopeProvider.kt | 25 +++--- .../scopes/impl/FirFakeOverrideGenerator.kt | 14 ++-- .../scopes/impl/FirNestedClassifierScope.kt | 5 +- .../scopes/impl/FirStandardOverrideChecker.kt | 2 +- .../scopes/impl/FirTypeIntersectionScope.kt | 2 +- .../kotlin/fir/types/ConeTypeContext.kt | 2 +- .../jetbrains/kotlin/fir/types/TypeUtils.kt | 5 +- .../api/fir/components/KtFirScopeProvider.kt | 2 +- 53 files changed, 191 insertions(+), 204 deletions(-) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt index 5b4c7b5723a..1c648b8d3c3 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirCallsEffectAnalyzer.kt @@ -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, 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 } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt index f24db9efd66..5b1a821867c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt @@ -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() } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt index 5495a1bd23a..33bf2f80150 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt @@ -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>): Boolean { - for (it in other.superTypeRefs) { - val that = it.firClassLike(declarationSiteSession) - ?.followAllAlias(declarationSiteSession) - ?.safeAs>() - ?: 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>): Boolean { for (it in other.superTypeRefs) { - val candidate = it.firClassLike(declarationSiteSession) - ?.followAllAlias(declarationSiteSession) + val candidate = it.firClassLike(session) + ?.followAllAlias(session) ?.safeAs>() ?: continue diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt index 6106cca64eb..02110e85f1d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt @@ -44,7 +44,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() { val isInterface = declaration.classKind == ClassKind.INTERFACE for (supertypeRef in supertypes) { val supertype = supertypeRef.coneTypeSafe() ?: 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 diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt index 87caaf8700e..15a4e00bc36 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineClassDeclarationChecker.kt @@ -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 -> diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt index b3d268acdf0..f6704951794 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt @@ -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) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt index 050bb109ab6..bbddcb3a34d 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirCallableReferenceChecker.kt @@ -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 && diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt index 32a239cbcd2..7ce4447f0c7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirNotASupertypeChecker.kt @@ -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) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt index 5a684a64e64..aee7f157193 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirQualifiedSupertypeExtendedByOtherSupertypeChecker.kt @@ -44,7 +44,7 @@ object FirQualifiedSupertypeExtendedByOtherSupertypeChecker : FirQualifiedAccess ?.followAllAlias(context.session).safeAs>() ?: continue - val isSupertype = explicitType.isSupertypeOf(that) + val isSupertype = explicitType.isSupertypeOf(that, context.session) if (explicitType == that || isSupertype) { if (isSupertype) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt index 4be43d8e180..1589e662ee4 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUpperBoundViolatedChecker.kt @@ -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) -> diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt index 0551fc88a09..e980cf9e6f6 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt @@ -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()) diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index 70499ccefa9..f61f4679eeb 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt @@ -200,7 +200,7 @@ class FirElementSerializer private constructor( @OptIn(ExperimentalStdlibApi::class) private fun FirClass<*>.declarations(): List> = 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), diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt index ec4444fadbc..c755b2bc7f2 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt @@ -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) diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt index d0ec6343240..c529ad0c11d 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt @@ -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 diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt index e75290add66..888d210b16f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/FirMetadataSource.kt @@ -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? diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 3cecf5920db..6851e023139 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -470,7 +470,7 @@ class CallAndReferenceGenerator( val type = typeProjection.typeRef.coneTypeSafe() ?: continue map[typeParameter.symbol] = type } - return ConeSubstitutorByMap(map) + return ConeSubstitutorByMap(map, session) } internal fun IrExpression.applyCallArguments(call: FirCall?, annotationMode: Boolean): IrExpression { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt index cdebc904e71..c476278b314 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaScopeProvider.kt @@ -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 { + private fun FirRegularClass.findClosestJavaSuperTypes(useSiteSession: FirSession): Collection { val result = mutableListOf() 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() { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index f815e5e4603..9bfdb4b9196 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -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) } } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 1017338c385..24aeca32e12 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -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, position: TypeComponentPosition -) = typeParameters.filterIsInstance().map { typeParameter -> +): List = typeParameters.filterIsInstance().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?) = diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt index 201905917df..bbd4ad54102 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt @@ -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 ) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt index 899c6a8068f..0049867d2f5 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt @@ -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() overrideCandidate.extractTypeParametersTo(typeParameters) baseDeclaration.extractTypeParametersTo(typeParameters) - return substitutorByMap(typeParameters.buildErasure()) + return substitutorByMap(typeParameters.buildErasure(), session) } override fun isOverriddenFunction(overrideCandidate: FirSimpleFunction, baseDeclaration: FirSimpleFunction): Boolean { diff --git a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt index 83921662a6c..6e23acdb9c6 100644 --- a/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt +++ b/compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt @@ -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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index 8527cde319c..dd5720fd76e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt index 564d284b752..fd496f1ec42 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SamResolution.kt @@ -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)) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt index 309365352b6..560d369abb6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt index 887e249ced6..ef7255c901d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt @@ -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, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt index d376e452249..c997613edee 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractConeCallConflictResolver.kt @@ -178,6 +178,6 @@ abstract class AbstractConeCallConflictResolver( } private fun createEmptyConstraintSystem(): SimpleConstraintSystem { - return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem()) + return ConeSimpleConstraintSystemImpl(inferenceComponents.createConstraintSystem(), inferenceComponents.session) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt index e26d478134f..31beea3070b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt @@ -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): 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) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt index 8892c7ab6c3..d2a31b0744d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt @@ -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 ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt index 1902dceca3d..6039d7a29cc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt @@ -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> { 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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt index afb7f214702..1d5b52b75ba 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt @@ -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 = LinkedHashMap(function.valueParameters.size) val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget? by lazy { - function.asForbiddenNamedArgumentsTarget + function.getAsForbiddenNamedArgumentsTarget(useSiteSession) } private enum class State { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index 334ccbb4f35..f60f8f82fce 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -195,7 +195,7 @@ internal object CheckVisibility : CheckerStage() { if (declaration is FirConstructor) { // TODO: Should be some other form - val classSymbol = declaration.returnTypeRef.coneTypeUnsafe().lookupTag.toSymbol(declaration.declarationSiteSession) + val classSymbol = declaration.returnTypeRef.coneTypeUnsafe().lookupTag.toSymbol(context.session) if (classSymbol is FirRegularClassSymbol) { if (classSymbol.fir.classKind.isSingleton) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt index a2f7da22584..9c2f7dcce5f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt @@ -875,7 +875,7 @@ abstract class FirDataFlowAnalyzer( val substitutionFromArguments = typeParameters.zip(qualifiedAccess.typeArguments).map { (typeParameterRef, typeArgument) -> typeParameterRef.symbol to typeArgument.toConeTypeProjection().type }.filter { it.second != null }.toMap() as Map - ConeSubstitutorByMap(substitutionFromArguments) + ConeSubstitutorByMap(substitutionFromArguments, components.session) } else { ConeSubstitutor.Empty } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt index 8f49f0437f6..049be4c93b8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt @@ -77,7 +77,7 @@ private fun extraLambdaInfo( ?: expectedType?.typeArguments?.singleOrNull()?.safeAs()?.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() ?: nothingType } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt index b4b016e6d93..370953eaf93 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt @@ -53,7 +53,7 @@ abstract class FirSymbolProvider(val session: FirSession) : FirSessionComponent fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Name): List> { val classSymbol = getClassLikeSymbolByFqName(classId) as? FirRegularClassSymbol ?: return emptyList() - val declaredMemberScope = declaredMemberScope(classSymbol.fir) + val declaredMemberScope = session.declaredMemberScope(classSymbol.fir) val result = mutableListOf>() declaredMemberScope.processPropertiesByName(name, result::add) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt index 38fa02b3416..235cb82132e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/substitution/Substitutors.kt @@ -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): ConeSubstitutor { +fun substitutorByMap(substitution: Map, 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) : AbstractConeSubstitutor() { +data class ConeSubstitutorByMap( + val substitution: Map, + 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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt index a2e8be36c91..eb11831e69c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt @@ -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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt index f5849dcc667..97bf9c24710 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt @@ -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) { val sealedClassInheritorsMap = mutableMapOf>() - 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>>() { + class InheritorsCollector(val session: FirSession) : FirDefaultVisitor>>() { override fun visitElement(element: FirElement, data: MutableMap>) {} override fun visitFile(file: FirFile, data: MutableMap>) { @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 1bddb2aa23f..75d791044f5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 7c4a5c50276..5d22966e193 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt @@ -160,9 +160,9 @@ private fun createScopesForNestedClasses( addIfNotNull(klass.typeParametersScope()) val companionObjects = klass.declarations.filterIsInstance().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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt index 371ac070ba8..66b57fb916e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt @@ -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) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt index 38e35da4bd4..6bcb52516f7 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/KotlinScopeProvider.kt @@ -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( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt index 6a6613c9aa9..0a0dc99806a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirAbstractOverrideChecker.kt @@ -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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt index 37d2b0c6578..5e6461d13d0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassDeclaredMemberScope.kt @@ -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? = 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>> = 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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 1be220915d9..919d30e9080 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt index f9ace8c8cf9..940c0b3c766 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt @@ -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, FirClassDeclaredMemberScope>() private val nestedClassifierCache = mutableMapOf, 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, 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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt index 3afdd764964..62102449004 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt @@ -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() } } @@ -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?, newTypeParameters: List?, @@ -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?, 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)) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt index ee6e8c45f59..4d70b80af2f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirNestedClassifierScope.kt @@ -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 = run { val result = mutableMapOf() 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 = classIndex.keys diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt index 4a6a73a1129..59229b41ff4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt @@ -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) -> diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt index b8d38484c6c..8def58bb5c3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirTypeIntersectionScope.kt @@ -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()?.let(substitutor::substituteOrSelf) ?: return false val bReturnType = b.fir.returnTypeRef.coneTypeSafe() ?: return false diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index a28ca83a7a7..6e8c7f39903 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt index 2dba1ad70c4..a70f64b8421 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt @@ -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] diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt index 7878c3e3d63..a70f5131f03 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt @@ -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)