diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index dbe2b7d0e3f..93c850632e3 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.isIteratorNext import org.jetbrains.kotlin.fir.resolve.scope import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.* @@ -445,7 +446,7 @@ class Fir2IrVisitor( private fun ConeKotlinType.doesContainReferencedSymbolInScope( referencedSymbol: AbstractFirBasedSymbol<*>, name: Name ): Boolean { - val scope = scope(session, components.scopeSession) ?: return false + val scope = scope(session, components.scopeSession, FakeOverrideTypeCalculator.Forced) ?: return false var result = false val processor = { it: FirCallableSymbol<*> -> if (!result && it == referencedSymbol) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt index e2c3fd81446..9ac4d69e0cd 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/AdapterGenerator.kt @@ -452,7 +452,7 @@ internal class AdapterGenerator( return if (argumentType.isBuiltinFunctionalType(session)) { argumentType.findBaseInvokeSymbol(session, scopeSession) } else { - argumentType.findContributedInvokeSymbol(session, scopeSession, expectedFunctionalType) + argumentType.findContributedInvokeSymbol(session, scopeSession, expectedFunctionalType, shouldCalculateReturnTypesOfFakeOverrides = true) }?.let { declarationStorage.getIrFunctionSymbol(it) as? IrSimpleFunctionSymbol } 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 2eda88ebf67..a8903cdf370 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 @@ -12,7 +12,9 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirTypeScope +import org.jetbrains.kotlin.fir.scopes.impl.FirScopeWithFakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.impl.FirStandardOverrideChecker import org.jetbrains.kotlin.fir.scopes.impl.FirTypeIntersectionScope import org.jetbrains.kotlin.fir.scopes.scopeForClass @@ -22,11 +24,15 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl -fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirTypeScope? = - scope(useSiteSession, scopeSession, FirResolvePhase.STATUS) - -fun ConeKotlinType.scopeForStatusResolve(useSiteSession: FirSession, scopeSession: ScopeSession): FirTypeScope? = - scope(useSiteSession, scopeSession, FirResolvePhase.TYPES) +fun ConeKotlinType.scope( + useSiteSession: FirSession, + scopeSession: ScopeSession, + fakeOverrideTypeCalculator: FakeOverrideTypeCalculator +): FirTypeScope? { + val scope = scope(useSiteSession, scopeSession, FirResolvePhase.STATUS) ?: return null + if (fakeOverrideTypeCalculator == FakeOverrideTypeCalculator.DoNothing) return scope + return FirScopeWithFakeOverrideTypeCalculator(scope, fakeOverrideTypeCalculator) +} private fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: ScopeSession, requiredPhase: FirResolvePhase): FirTypeScope? { return when (this) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index c1b7f5a3fd3..a217d289950 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt @@ -260,7 +260,12 @@ private fun argumentTypeWithSuspendConversion( // We want to check the argument type against non-suspend functional type. val expectedFunctionalType = expectedType.suspendFunctionTypeToFunctionType(session) if (argumentType.isSubtypeOfFunctionalType(session, expectedFunctionalType)) { - return argumentType.findContributedInvokeSymbol(session, scopeSession, expectedFunctionalType)?.let { invokeSymbol -> + return argumentType.findContributedInvokeSymbol( + session, + scopeSession, + expectedFunctionalType, + shouldCalculateReturnTypesOfFakeOverrides = false + )?.let { invokeSymbol -> createFunctionalType( invokeSymbol.fir.valueParameters.map { it.returnTypeRef.coneType }, null, 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 24f45247b0f..96adef52e99 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 @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator import org.jetbrains.kotlin.fir.scopes.scopeForClass @@ -145,7 +146,7 @@ private fun processConstructors( is FirTypeAliasSymbol -> { matchedSymbol.ensureResolved(FirResolvePhase.TYPES, session) val type = matchedSymbol.fir.expandedTypeRef.coneTypeUnsafe().fullyExpandedType(session) - val basicScope = type.scope(session, bodyResolveComponents.scopeSession) + val basicScope = type.scope(session, bodyResolveComponents.scopeSession, FakeOverrideTypeCalculator.DoNothing) if (basicScope != null && type.typeArguments.isNotEmpty()) { prepareSubstitutingScopeForTypeAliasConstructors( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt index 2428f8df7c0..72ea98e6842 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirReceivers.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.scope import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -32,7 +33,7 @@ interface ReceiverValue : Receiver { val receiverExpression: FirExpression fun scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirTypeScope? = - type.scope(useSiteSession, scopeSession) + type.scope(useSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing) } // TODO: should inherit just Receiver, not ReceiverValue @@ -63,7 +64,7 @@ sealed class ImplicitReceiverValue>( final override var type: ConeKotlinType = type private set - var implicitScope: FirTypeScope? = type.scope(useSiteSession, scopeSession) + var implicitScope: FirTypeScope? = type.scope(useSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing) private set override fun scope(useSiteSession: FirSession, scopeSession: ScopeSession): FirTypeScope? = implicitScope @@ -87,7 +88,7 @@ sealed class ImplicitReceiverValue>( typesFromSmartCast = listOf(type) } } - implicitScope = type.scope(useSiteSession, scopeSession) + implicitScope = type.scope(useSiteSession, scopeSession, FakeOverrideTypeCalculator.DoNothing) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/SuperCalls.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/SuperCalls.kt index 3eae10aa667..fd3eef45bf6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/SuperCalls.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/SuperCalls.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.scope import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.unwrapSubstitutionOverrides @@ -119,18 +120,20 @@ private inline fun BodyResolveComponents.resolveSupertypesByMembers( } @OptIn(ExperimentalStdlibApi::class) -private fun BodyResolveComponents.getFunctionMembers(type: ConeKotlinType, name: Name): Collection> = buildList { - type.scope(session, scopeSession)?.processFunctionsByName(name) { - addIfNotNull(it.fir as? FirSimpleFunction) +private fun BodyResolveComponents.getFunctionMembers(type: ConeKotlinType, name: Name): Collection> = + buildList { + type.scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)?.processFunctionsByName(name) { + addIfNotNull(it.fir as? FirSimpleFunction) + } } -} @OptIn(ExperimentalStdlibApi::class) -private fun BodyResolveComponents.getPropertyMembers(type: ConeKotlinType, name: Name): Collection> = buildList { - type.scope(session, scopeSession)?.processPropertiesByName(name) { - addIfNotNull(it.fir as? FirProperty) +private fun BodyResolveComponents.getPropertyMembers(type: ConeKotlinType, name: Name): Collection> = + buildList { + type.scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)?.processPropertiesByName(name) { + addIfNotNull(it.fir as? FirProperty) + } } -} private fun BodyResolveComponents.isConcreteMember(supertype: ConeKotlinType, member: FirCallableMemberDeclaration<*>): Boolean { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolveTask.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolveTask.kt index 7a40f780220..bd6406e3af3 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolveTask.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolveTask.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.FirTowerDataContext import org.jetbrains.kotlin.fir.resolve.calls.* import org.jetbrains.kotlin.fir.resolve.scope +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirCompositeScope import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.ProcessorAction @@ -287,9 +288,11 @@ internal open class FirTowerResolveTask( superTypeRef: FirTypeRef ) { val scope = when (superTypeRef) { - is FirResolvedTypeRef -> superTypeRef.type.scope(session, components.scopeSession) + is FirResolvedTypeRef -> superTypeRef.type.scope(session, components.scopeSession, FakeOverrideTypeCalculator.DoNothing) is FirComposedSuperTypeRef -> FirCompositeScope( - superTypeRef.superTypeRefs.mapNotNull { it.type.scope(session, components.scopeSession) } + superTypeRef.superTypeRefs.mapNotNull { + it.type.scope(session, components.scopeSession, FakeOverrideTypeCalculator.DoNothing) + } ) else -> null } ?: return diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt index b5deea66a27..37879b83e89 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolver.kt @@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.* import org.jetbrains.kotlin.fir.resolve.scope +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.types.ConeClassLikeType import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -86,7 +87,7 @@ class FirTowerResolver( context: ResolutionContext ): CandidateCollector { val outerType = components.outerClassManager.outerType(constructedType) - val scope = constructedType.scope(components.session, components.scopeSession) ?: return collector + val scope = constructedType.scope(components.session, components.scopeSession, FakeOverrideTypeCalculator.DoNothing) ?: return collector val dispatchReceiver = if (outerType != null) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt index 49a045efae4..abdcd9e1ce6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceUtils.kt @@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.typeContext import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl @@ -94,11 +95,17 @@ fun ConeClassLikeType.findBaseInvokeSymbol(session: FirSession, scopeSession: Sc fun ConeKotlinType.findContributedInvokeSymbol( session: FirSession, scopeSession: ScopeSession, - expectedFunctionalType: ConeClassLikeType + expectedFunctionalType: ConeClassLikeType, + shouldCalculateReturnTypesOfFakeOverrides: Boolean ): FirFunctionSymbol<*>? { val baseInvokeSymbol = expectedFunctionalType.findBaseInvokeSymbol(session, scopeSession) ?: return null - val scope = scope(session, scopeSession) ?: return null + val fakeOverrideTypeCalculator = if (shouldCalculateReturnTypesOfFakeOverrides) { + FakeOverrideTypeCalculator.Forced + } else { + FakeOverrideTypeCalculator.DoNothing + } + val scope = scope(session, scopeSession, fakeOverrideTypeCalculator) ?: return null var declaredInvoke: FirFunctionSymbol<*>? = null scope.processFunctionsByName(OperatorNameConventions.INVOKE) { functionSymbol -> if (functionSymbol.fir.valueParameters.size == baseInvokeSymbol.fir.valueParameters.size) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt index ac59868c603..c64f181ee01 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt @@ -9,8 +9,6 @@ import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.render -import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator -import org.jetbrains.kotlin.fir.scopes.ForcedFakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 8c3672918cd..6ab7a388f1a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.firProvider import org.jetbrains.kotlin.fir.resolve.transformers.* import org.jetbrains.kotlin.fir.resolve.transformers.contracts.runContractResolveForLocalClass -import org.jetbrains.kotlin.fir.scopes.ForcedFakeOverrideTypeCalculator +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.symbols.PossiblyFirFakeOverrideSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -223,7 +223,7 @@ private class ReturnTypeCalculatorWithJump( val possiblyFirFakeOverrideSymbol = declaration.symbol as PossiblyFirFakeOverrideSymbol<*, *> val overriddenDeclaration = possiblyFirFakeOverrideSymbol.overriddenSymbol?.fir as FirTypedDeclaration? ?: return@runIf tryCalculateReturnType(overriddenDeclaration) - return ForcedFakeOverrideTypeCalculator.computeReturnType(declaration) + return FakeOverrideTypeCalculator.Forced.computeReturnType(declaration) } return when (val status = implicitBodyResolveComputationSession.getStatus(declaration.symbol)) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FakeOverrideTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FakeOverrideTypeCalculator.kt index c95592b157d..b5ef04e63e9 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FakeOverrideTypeCalculator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/FakeOverrideTypeCalculator.kt @@ -23,19 +23,19 @@ abstract class FakeOverrideTypeCalculator { return declaration.returnTypeRef } } -} -object ForcedFakeOverrideTypeCalculator : FakeOverrideTypeCalculator() { - override fun computeReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef { - (declaration.returnTypeRef as? FirResolvedTypeRef)?.let { return it } - val (substitutor, baseSymbol) = declaration.attributes.fakeOverrideSubstitution ?: error("") - val baseDeclaration = baseSymbol.fir as FirTypedDeclaration - val baseReturnType = computeReturnType(baseDeclaration).type - declaration.attributes.fakeOverrideSubstitution = null - val coneType = substitutor.substituteOrSelf(baseReturnType) - val returnType = declaration.returnTypeRef.resolvedTypeFromPrototype(coneType) - declaration.replaceReturnTypeRef(returnType) - return returnType + object Forced : FakeOverrideTypeCalculator() { + override fun computeReturnType(declaration: FirTypedDeclaration): FirResolvedTypeRef { + (declaration.returnTypeRef as? FirResolvedTypeRef)?.let { return it } + val (substitutor, baseSymbol) = declaration.attributes.fakeOverrideSubstitution ?: error("") + val baseDeclaration = baseSymbol.fir as FirTypedDeclaration + val baseReturnType = computeReturnType(baseDeclaration).type + declaration.attributes.fakeOverrideSubstitution = null + val coneType = substitutor.substituteOrSelf(baseReturnType) + val returnType = declaration.returnTypeRef.resolvedTypeFromPrototype(coneType) + declaration.replaceReturnTypeRef(returnType) + return returnType + } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirScopeWithFakeOverrideTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirScopeWithFakeOverrideTypeCalculator.kt new file mode 100644 index 00000000000..5bfb9d7ff17 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirScopeWithFakeOverrideTypeCalculator.kt @@ -0,0 +1,80 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.scopes.impl + +import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin +import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration +import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator +import org.jetbrains.kotlin.fir.scopes.FirTypeScope +import org.jetbrains.kotlin.fir.scopes.ProcessorAction +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.name.Name + +class FirScopeWithFakeOverrideTypeCalculator( + private val delegate: FirTypeScope, + private val fakeOverrideTypeCalculator: FakeOverrideTypeCalculator +) : FirTypeScope() { + override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) { + delegate.processClassifiersByNameWithSubstitution(name, processor) + } + + override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) { + delegate.processFunctionsByName(name) { + updateReturnType(it.fir) + processor(it) + } + } + + override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) { + delegate.processPropertiesByName(name) { + updateReturnType(it.fir) + processor(it) + } + } + + override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) { + delegate.processDeclaredConstructors(processor) + } + + override fun mayContainName(name: Name): Boolean { + return delegate.mayContainName(name) + } + + override fun processDirectOverriddenFunctionsWithBaseScope( + functionSymbol: FirFunctionSymbol<*>, + processor: (FirFunctionSymbol<*>, FirTypeScope) -> ProcessorAction + ): ProcessorAction { + return delegate.processDirectOverriddenFunctionsWithBaseScope(functionSymbol) { symbol, scope -> + updateReturnType(symbol.fir) + processor(symbol, scope) + } + } + + override fun processDirectOverriddenPropertiesWithBaseScope( + propertySymbol: FirPropertySymbol, + processor: (FirPropertySymbol, FirTypeScope) -> ProcessorAction + ): ProcessorAction { + return delegate.processDirectOverriddenPropertiesWithBaseScope(propertySymbol) { symbol, scope -> + updateReturnType(symbol.fir) + processor(symbol, scope) + } + } + + override fun getCallableNames(): Set { + return delegate.getCallableNames() + } + + override fun getClassifierNames(): Set { + return delegate.getClassifierNames() + } + + private fun updateReturnType(declaration: FirTypedDeclaration) { + if (declaration.origin == FirDeclarationOrigin.FakeOverride || declaration.origin == FirDeclarationOrigin.IntersectionOverride) { + fakeOverrideTypeCalculator.computeReturnType(declaration) + } + } +} 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 c4ef67772a9..ec865f90436 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 @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components import com.intellij.openapi.project.Project import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.scope +import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.impl.* @@ -91,8 +92,11 @@ internal class KtFirScopeProvider( override fun getTypeScope(type: KtType): KtScope? { check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" } val firSession = firResolveState.rootModuleSession - val firTypeScope = type.coneType.scope(firSession, firResolveState.firTransformerProvider.getScopeSession(firSession)) - ?: return null + val firTypeScope = type.coneType.scope( + firSession, + firResolveState.firTransformerProvider.getScopeSession(firSession), + FakeOverrideTypeCalculator.Forced + ) ?: return null return convertToKtScope(firTypeScope) }