From 7927ef9f6607d10b94f642081194ab0c71643f79 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Thu, 19 Mar 2020 11:54:03 +0300 Subject: [PATCH] FIR: Extract BodyResolveContext from BodyResolveTransformerComponents Its content is assumed to be changing and might be injected into body resolver --- .../fir/resolve/BodyResolveComponents.kt | 6 +- .../fir/resolve/inference/FirCallCompleter.kt | 4 +- .../FirAbstractBodyResolveTransformer.kt | 100 +++++++++--------- .../body/resolve/FirBodyResolveTransformer.kt | 12 ++- .../FirDeclarationsResolveTransformer.kt | 24 ++--- .../body/resolve/FirImplicitBodyResolve.kt | 2 +- .../FirPartialBodyResolveTransformer.kt | 9 +- .../kotlin/idea/fir/FirResolutionApi.kt | 2 +- 8 files changed, 83 insertions(+), 76 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt index d2e6326c436..b011274b815 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/BodyResolveComponents.kt @@ -30,7 +30,7 @@ interface SessionHolder { interface BodyResolveComponents : SessionHolder { val returnTypeCalculator: ReturnTypeCalculator - val implicitReceiverStack: MutableImplicitReceiverStack + val implicitReceiverStack: ImplicitReceiverStack val fileImportsScope: List val typeParametersScopes: List val localScopes: FirLocalScopes @@ -52,12 +52,10 @@ interface BodyResolveComponents : SessionHolder { val AbstractFirBasedSymbol.phasedFir: D where D : FirDeclaration, D : FirSymbolOwner get() = phasedFir(FirResolvePhase.DECLARATIONS) - - fun saveContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) - fun dropContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) } typealias FirLocalScopes = PersistentList +typealias FirTypeParametersScopes = PersistentList class FirLocalContext( val localScopes: FirLocalScopes, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index 02b5b49e726..e78937d22a2 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt @@ -189,10 +189,10 @@ class FirCallCompleter( lambdaArgument.replaceReturnTypeRef(expectedReturnTypeRef ?: noExpectedType) val localContext = localContextForAnonymousFunctions.getValue(lambdaArgument.symbol) - transformer.components.withLocalContext(localContext) { + transformer.context.withLocalContext(localContext) { lambdaArgument.transformSingle(transformer, ResolutionMode.LambdaResolution(expectedReturnTypeRef)) } - dropContextForAnonymousFunction(lambdaArgument) + transformer.context.dropContextForAnonymousFunction(lambdaArgument) val returnArguments = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(lambdaArgument) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt index 9c4a5d24f18..8c3d6e92e88 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve -import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.persistentListOf import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* @@ -24,6 +23,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAbstractPhaseTransformer(phase) { + abstract val context: BodyResolveContext abstract val components: BodyResolveTransformerComponents @set:PrivateForInline @@ -52,12 +52,12 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb } protected inline fun withLocalScopeCleanup(crossinline l: () -> T): T { - return components.withLocalScopesCleanup(l) + return context.withLocalScopesCleanup(l) } protected fun addLocalScope(localScope: FirLocalScope?) { if (localScope == null) return - components.addLocalScope(localScope) + context.addLocalScope(localScope) } @@ -78,7 +78,7 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb protected inline val symbolProvider: FirSymbolProvider get() = components.symbolProvider - protected inline val implicitReceiverStack: MutableImplicitReceiverStack get() = components.implicitReceiverStack + protected inline val implicitReceiverStack: ImplicitReceiverStack get() = components.implicitReceiverStack protected inline val inferenceComponents: InferenceComponents get() = components.inferenceComponents protected inline val resolutionStageRunner: ResolutionStageRunner get() = components.resolutionStageRunner protected inline val samResolver: FirSamResolver get() = components.samResolver @@ -99,62 +99,26 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb else -> null } - class BodyResolveTransformerComponents( - override val session: FirSession, - override val scopeSession: ScopeSession, - val transformer: FirBodyResolveTransformer - ) : BodyResolveComponents { - override val fileImportsScope: MutableList = mutableListOf() + class BodyResolveContext(val returnTypeCalculator: ReturnTypeCalculator) { + val fileImportsScope: MutableList = mutableListOf() @set:PrivateForInline - override var typeParametersScopes: PersistentList = persistentListOf() + var typeParametersScopes: FirTypeParametersScopes = persistentListOf() @set:PrivateForInline - override var localScopes: FirLocalScopes = persistentListOf() - - override val noExpectedType: FirTypeRef = buildImplicitTypeRef() - - override val localContextForAnonymousFunctions: MutableMap = mutableMapOf() + var localScopes: FirLocalScopes = persistentListOf() @set:PrivateForInline - override lateinit var file: FirFile + lateinit var file: FirFile internal set - override val symbolProvider: FirSymbolProvider = session.firSymbolProvider - - override val returnTypeCalculator: ReturnTypeCalculator = transformer.returnTypeCalculator - @set:PrivateForInline - override var implicitReceiverStack: MutableImplicitReceiverStack = ImplicitReceiverStackImpl() - - override val inferenceComponents: InferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession) - override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner(inferenceComponents) - override val samResolver: FirSamResolver = FirSamResolverImpl(session, scopeSession) - override val doubleColonExpressionResolver: FirDoubleColonExpressionResolver = FirDoubleColonExpressionResolver(session) - private val qualifiedResolver: FirQualifiedNameResolver = FirQualifiedNameResolver(this) - override val callResolver: FirCallResolver = FirCallResolver( - this, - qualifiedResolver - ) - val typeResolverTransformer = FirSpecificTypeResolverTransformer( - FirTypeResolveScopeForBodyResolve(this), session - ) - override val callCompleter: FirCallCompleter = FirCallCompleter(transformer, this) - override val dataFlowAnalyzer: FirDataFlowAnalyzer<*> = FirDataFlowAnalyzer.createFirDataFlowAnalyzer(this) - override val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this) - override val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer = - IntegerLiteralTypeApproximationTransformer(symbolProvider, inferenceComponents.ctx) - override val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater = IntegerOperatorsTypeUpdater(integerLiteralTypeApproximator) + var implicitReceiverStack: MutableImplicitReceiverStack = ImplicitReceiverStackImpl() @set:PrivateForInline var containerIfAny: FirDeclaration? = null - override var container: FirDeclaration - get() = containerIfAny!! - private set(value) { - @OptIn(PrivateForInline::class) - containerIfAny = value - } + val localContextForAnonymousFunctions: MutableMap = mutableMapOf() @OptIn(PrivateForInline::class) inline fun withContainer(declaration: FirDeclaration, crossinline f: () -> T): T { @@ -208,11 +172,11 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb updateLastScope { storeVariable(variable) } } - override fun saveContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) { + fun saveContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) { localContextForAnonymousFunctions[anonymousFunction.symbol] = FirLocalContext(localScopes, implicitReceiverStack.snapshot()) } - override fun dropContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) { + fun dropContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) { localContextForAnonymousFunctions.remove(anonymousFunction.symbol) } @@ -226,5 +190,43 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb localScopes = localScopes.set(localScopes.size - 1, lastScope.transform()) } } + + class BodyResolveTransformerComponents( + override val session: FirSession, + override val scopeSession: ScopeSession, + val transformer: FirBodyResolveTransformer, + private val context: BodyResolveContext + ) : BodyResolveComponents { + override val fileImportsScope: List get() = context.fileImportsScope + override val typeParametersScopes: List get() = context.typeParametersScopes + override val localScopes: FirLocalScopes get() = context.localScopes + override val file: FirFile get() = context.file + override val implicitReceiverStack: ImplicitReceiverStack get() = context.implicitReceiverStack + override val localContextForAnonymousFunctions: LocalContextForAnonymousFunctions get() = context.localContextForAnonymousFunctions + override val returnTypeCalculator: ReturnTypeCalculator get() = context.returnTypeCalculator + override val container: FirDeclaration get() = context.containerIfAny!! + + override val noExpectedType: FirTypeRef = buildImplicitTypeRef() + override val symbolProvider: FirSymbolProvider = session.firSymbolProvider + + override val inferenceComponents: InferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession) + override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner(inferenceComponents) + override val samResolver: FirSamResolver = FirSamResolverImpl(session, scopeSession) + override val doubleColonExpressionResolver: FirDoubleColonExpressionResolver = FirDoubleColonExpressionResolver(session) + private val qualifiedResolver: FirQualifiedNameResolver = FirQualifiedNameResolver(this) + override val callResolver: FirCallResolver = FirCallResolver( + this, + qualifiedResolver + ) + val typeResolverTransformer = FirSpecificTypeResolverTransformer( + FirTypeResolveScopeForBodyResolve(this), session + ) + override val callCompleter: FirCallCompleter = FirCallCompleter(transformer, this) + override val dataFlowAnalyzer: FirDataFlowAnalyzer<*> = FirDataFlowAnalyzer.createFirDataFlowAnalyzer(this) + override val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this) + override val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer = + IntegerLiteralTypeApproximationTransformer(symbolProvider, inferenceComponents.ctx) + override val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater = IntegerOperatorsTypeUpdater(integerLiteralTypeApproximator) + } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index 092d158d676..237cb3d1bd6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt @@ -30,19 +30,21 @@ open class FirBodyResolveTransformer( ) : FirAbstractBodyResolveTransformer(phase) { private var packageFqName = FqName.ROOT - override val components: BodyResolveTransformerComponents = BodyResolveTransformerComponents(session, scopeSession, this) + final override val context: BodyResolveContext = BodyResolveContext(returnTypeCalculator) + final override val components: BodyResolveTransformerComponents = + BodyResolveTransformerComponents(session, scopeSession, this, context) private val expressionsTransformer = FirExpressionsResolveTransformer(this) private val declarationsTransformer = FirDeclarationsResolveTransformer(this) private val controlFlowStatementsTransformer = FirControlFlowStatementsResolveTransformer(this) override fun transformFile(file: FirFile, data: ResolutionMode): CompositeTransformResult { - components.cleanContextForAnonymousFunction() + context.cleanContextForAnonymousFunction() @OptIn(PrivateForInline::class) - components.file = file + context.file = file packageFqName = file.packageFqName - return withScopeCleanup(components.fileImportsScope) { - components.fileImportsScope.addImportingScopes(file, session, components.scopeSession) + return withScopeCleanup(context.fileImportsScope) { + context.fileImportsScope.addImportingScopes(file, session, components.scopeSession) super.transformFile(file, data) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index ab037d6e6e9..d184bf49cf0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -39,7 +39,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) private var containingClass: FirRegularClass? = null override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { - return components.withContainer(declaration) { + return context.withContainer(declaration) { declaration.replaceResolvePhase(transformerPhase) transformer.transformElement(declaration, data) } @@ -71,14 +71,14 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) typeParameter.transformChildren(transformer, ResolutionMode.ContextIndependent) } - val before = components.typeParametersScopes + val before = context.typeParametersScopes @OptIn(PrivateForInline::class) - components.typeParametersScopes = components.typeParametersScopes.add(FirMemberTypeParameterScope(declaration)) + context.typeParametersScopes = context.typeParametersScopes.add(FirMemberTypeParameterScope(declaration)) return try { l() } finally { @OptIn(PrivateForInline::class) - components.typeParametersScopes = before + context.typeParametersScopes = before } } @@ -106,7 +106,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) dataFlowAnalyzer.enterProperty(property) withFullBodyResolve { withLocalScopeCleanup { - components.withContainer(property) { + context.withContainer(property) { if (property.delegate != null) { addLocalScope(primaryConstructorParametersScope) transformPropertyWithDelegate(property) @@ -203,7 +203,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } variable.transformAccessors() } - components.storeVariable(variable) + context.storeVariable(variable) variable.replaceResolvePhase(transformerPhase) dataFlowAnalyzer.exitLocalVariableDeclaration(variable) return variable.compose() @@ -263,7 +263,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } private fun FirDeclaration.resolveStatus(status: FirDeclarationStatus, containingClass: FirClass<*>? = null): FirDeclarationStatus { - val containingDeclaration = components.containerIfAny + val containingDeclaration = context.containerIfAny return resolveStatus( status, containingClass as? FirRegularClass, isLocal = containingDeclaration != null && containingClass == null ) @@ -307,7 +307,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): CompositeTransformResult { - components.storeClass(regularClass) + context.storeClass(regularClass) return withTypeParametersOf(regularClass) { if (regularClass.symbol.classId.isLocal) { prepareLocalClassForBodyResolve(regularClass) @@ -390,7 +390,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } return withTypeParametersOf(simpleFunction) { - val containingDeclaration = components.containerIfAny + val containingDeclaration = context.containerIfAny if (containingDeclaration != null && containingDeclaration !is FirClass<*>) { // For class members everything should be already prepared prepareSignatureForBodyResolve(simpleFunction) @@ -415,7 +415,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) resolutionMode: ResolutionMode, ): CompositeTransformResult { if (function is FirSimpleFunction) { - components.storeFunction(function) + context.storeFunction(function) } @Suppress("UNCHECKED_CAST") @@ -472,7 +472,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): CompositeTransformResult { - components.storeVariable(valueParameter) + context.storeVariable(valueParameter) if (valueParameter.returnTypeRef is FirImplicitTypeRef) { valueParameter.replaceResolvePhase(transformerPhase) return valueParameter.compose() // TODO @@ -490,7 +490,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) anonymousFunction.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) anonymousFunction.transformReceiverTypeRef(transformer, ResolutionMode.ContextIndependent) anonymousFunction.valueParameters.forEach { it.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent) } - components.saveContextForAnonymousFunction(anonymousFunction) + context.saveContextForAnonymousFunction(anonymousFunction) } return when (data) { ResolutionMode.ContextDependent -> { 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 917130fdbb4..a8c6e92e887 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 @@ -200,7 +200,7 @@ private class FirDesignatedBodyResolveTransformerForReturnTypeCalculator( } override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { - return components.withContainer(declaration) { + return context.withContainer(declaration) { declaration.replaceResolvePhase(transformerPhase) transformElement(declaration, data) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt index 395a354f5eb..f80d07eecac 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirPartialBodyResolveTransformer.kt @@ -14,7 +14,12 @@ abstract class FirPartialBodyResolveTransformer( val transformer: FirBodyResolveTransformer ) : FirAbstractBodyResolveTransformer(transformer.transformerPhase) { @Suppress("OVERRIDE_BY_INLINE") - final override inline val components: BodyResolveTransformerComponents get() = transformer.components + final override inline val context: BodyResolveContext + get() = transformer.context + + @Suppress("OVERRIDE_BY_INLINE") + final override inline val components: BodyResolveTransformerComponents + get() = transformer.components @set:PrivateForInline override var implicitTypeOnly: Boolean @@ -26,4 +31,4 @@ abstract class FirPartialBodyResolveTransformer( override fun transformElement(element: E, data: ResolutionMode): CompositeTransformResult { return element.transform(transformer, data) } -} \ No newline at end of file +} diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt index dae6d79e7ed..3054f1e0775 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirResolutionApi.kt @@ -223,7 +223,7 @@ private class FirDesignatedBodyResolveTransformerForIDE( } override fun transformDeclaration(declaration: FirDeclaration, data: ResolutionMode): CompositeTransformResult { - return components.withContainer(declaration) { + return context.withContainer(declaration) { declaration.replaceResolvePhase(transformerPhase) transformElement(declaration, data) }