From db2b6e92e592555f2342e785c16ff4bde390ef93 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 4 Mar 2021 13:29:35 +0300 Subject: [PATCH] FIR: extract BodyResolveContext.withAnonymousObject --- .../body/resolve/BodyResolveContext.kt | 29 ++++--- .../FirDeclarationsResolveTransformer.kt | 82 +------------------ 2 files changed, 21 insertions(+), 90 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt index 1490f18954c..9222fbee4eb 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.persistentListOf +import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirFakeSourceElementKind import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.declarations.* @@ -25,7 +26,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirMemberTypeParameterScope import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.name.Name class BodyResolveContext( @@ -272,19 +272,28 @@ class BodyResolveContext( } } - withScopesForClass(regularClass.name, regularClass, regularClass.defaultType(), holder) { - f() - } + withScopesForClass(regularClass, holder, f) } } + inline fun withAnonymousObject( + anonymousObject: FirAnonymousObject, + holder: SessionHolder, + crossinline f: () -> T + ): T { + return withScopesForClass(anonymousObject, holder, f) + } + inline fun withScopesForClass( - labelName: Name?, owner: FirClass<*>, - type: ConeKotlinType, holder: SessionHolder, f: () -> T ): T { + val labelName = (owner as? FirRegularClass)?.name + ?: if (owner.classKind == ClassKind.ENUM_ENTRY) { + owner.primaryConstructor?.symbol?.callableId?.className?.shortName() + } else null + val type = owner.defaultType() val towerElementsForClass = holder.collectTowerDataElementsForClass(owner, type) val base = towerDataContext.addNonLocalTowerDataElements(towerElementsForClass.superClassesStaticsAndCompanionReceivers) @@ -298,7 +307,7 @@ class BodyResolveContext( .addNonLocalScopeIfNotNull(towerElementsForClass.companionStaticScope) .addNonLocalScopeIfNotNull(towerElementsForClass.staticScope) - val typeParameterScope = (owner as? FirRegularClass)?.let(this::createTypeParameterScope) + val typeParameterScope = (owner as? FirRegularClass)?.typeParameterScope() val forMembersResolution = staticsAndCompanion @@ -336,9 +345,9 @@ class BodyResolveContext( } } - fun createTypeParameterScope(declaration: FirMemberDeclaration): FirMemberTypeParameterScope? { - if (declaration.typeParameters.isEmpty()) return null - return FirMemberTypeParameterScope(declaration) + fun FirMemberDeclaration.typeParameterScope(): FirMemberTypeParameterScope? { + if (typeParameters.isEmpty()) return null + return FirMemberTypeParameterScope(this) } fun FirConstructor.scopesWithPrimaryConstructorParameters( 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 47418f81142..63b83cdad5e 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 @@ -431,18 +431,13 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor return anonymousObject.runAllPhasesForLocalClass(transformer, components, data).compose() } dataFlowAnalyzer.enterClass() - val type = anonymousObject.defaultType() if (anonymousObject.typeRef !is FirResolvedTypeRef) { anonymousObject.resultType = buildResolvedTypeRef { source = anonymousObject.source - this.type = type + this.type = anonymousObject.defaultType() } } - val labelName = - if (anonymousObject.classKind == ClassKind.ENUM_ENTRY) { - anonymousObject.primaryConstructor?.symbol?.callableId?.className?.shortName() - } else null - val result = withScopesForClass(labelName, anonymousObject, type) { + val result = context.withAnonymousObject(anonymousObject, components) { transformDeclarationContent(anonymousObject, data).single as FirAnonymousObject } if (!implicitTypeOnly && result.controlFlowGraphReference == null) { @@ -879,83 +874,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor return this } - private inline fun withScopesForClass( - labelName: Name?, - owner: FirClass<*>, - type: ConeKotlinType, - block: () -> T - ): T { - val towerElementsForClass = components.collectTowerDataElementsForClass(owner, type) - - val base = context.towerDataContext.addNonLocalTowerDataElements(towerElementsForClass.superClassesStaticsAndCompanionReceivers) - val statics = base - .addNonLocalScopeIfNotNull(towerElementsForClass.companionStaticScope) - .addNonLocalScopeIfNotNull(towerElementsForClass.staticScope) - - val companionReceiver = towerElementsForClass.companionReceiver - val staticsAndCompanion = if (companionReceiver == null) statics else base - .addReceiver(null, companionReceiver) - .addNonLocalScopeIfNotNull(towerElementsForClass.companionStaticScope) - .addNonLocalScopeIfNotNull(towerElementsForClass.staticScope) - - val typeParameterScope = (owner as? FirRegularClass)?.let(this::createTypeParameterScope) - - val forMembersResolution = - staticsAndCompanion - .addReceiver(labelName, towerElementsForClass.thisReceiver) - .addNonLocalScopeIfNotNull(typeParameterScope) - - val scopeForConstructorHeader = - staticsAndCompanion.addNonLocalScopeIfNotNull(typeParameterScope) - - val newTowerDataContextForStaticNestedClasses = - if ((owner as? FirRegularClass)?.classKind?.isSingleton == true) - forMembersResolution - else - staticsAndCompanion - - val constructor = (owner as? FirRegularClass)?.declarations?.firstOrNull { it is FirConstructor } as? FirConstructor - val (primaryConstructorPureParametersScope, primaryConstructorAllParametersScope) = - if (constructor?.isPrimary == true) { - constructor.scopesWithPrimaryConstructorParameters(owner) - } else { - null to null - } - - val newContexts = FirTowerDataContextsForClassParts( - forMembersResolution, - newTowerDataContextForStaticNestedClasses, - statics, - scopeForConstructorHeader, - primaryConstructorPureParametersScope, - primaryConstructorAllParametersScope - ) - - return context.withNewTowerDataForClassParts(newContexts) { - block() - } - } - private fun FirConstructor.scopeWithParameters(): FirLocalScope { return valueParameters.fold(FirLocalScope()) { acc, param -> acc.storeVariable(param) } } - private fun FirConstructor.scopesWithPrimaryConstructorParameters( - ownerClass: FirClass<*> - ): Pair { - var parameterScope = FirLocalScope() - var allScope = FirLocalScope() - val properties = ownerClass.declarations.filterIsInstance().associateBy { it.name } - for (parameter in valueParameters) { - allScope = allScope.storeVariable(parameter) - val property = properties[parameter.name] - if (property?.source?.kind != FirFakeSourceElementKind.PropertyFromParameter) { - parameterScope = parameterScope.storeVariable(parameter) - } - } - return parameterScope to allScope - } - protected inline fun withLabelAndReceiverType( labelName: Name?, owner: FirCallableDeclaration<*>,