FIR: refactor property & initializer resolve

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt

@@ -181,6 +181,10 @@ class BodyResolveContext(
         updateLastScope { storeVariable(variable) }
     }
 
+    fun storeBackingField(property: FirProperty) {
+        updateLastScope { storeBackingField(property) }
+    }
+
     fun saveContextForAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
         towerDataContextForAnonymousFunctions[anonymousFunction.symbol] = towerDataContext
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt

@@ -59,6 +59,16 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb
         }
     }
 
+    protected inline fun <T> withPrimaryConstructorParameters(includeProperties: Boolean, crossinline l: () -> T): T {
+        return context.withTowerDataCleanup {
+            addLocalScope(
+                if (includeProperties) context.getPrimaryConstructorAllParametersScope()
+                else context.getPrimaryConstructorPureParametersScope()
+            )
+            l()
+        }
+    }
+
     protected fun addNewLocalScope() {
         context.addLocalScope(FirLocalScope())
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -141,34 +141,31 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             }
             dataFlowAnalyzer.enterProperty(property)
             withFullBodyResolve {
-                withLocalScopeCleanup {
+                context.withContainer(property) {
-                    val primaryConstructorParametersScope = context.getPrimaryConstructorPureParametersScope()
+                    withPrimaryConstructorParameters(includeProperties = false) {
-                    context.withContainer(property) {
                         if (property.delegate != null) {
-                            addLocalScope(primaryConstructorParametersScope)
                             transformPropertyWithDelegate(property)
                         } else {
-                            withLocalScopeCleanup {
+                            property.transformChildrenWithoutAccessors(returnTypeRef)
-                                addLocalScope(primaryConstructorParametersScope)
-                                property.transformChildrenWithoutAccessors(returnTypeRef)
-                            }
                             if (property.initializer != null) {
                                 storeVariableReturnType(property)
                             }
-                            withLocalScopeCleanup {
-                                if (property.receiverTypeRef == null && property.returnTypeRef !is FirImplicitTypeRef) {
-                                    addLocalScope(FirLocalScope().storeBackingField(property))
-                                }
-                                property.transformAccessors()
-                            }
                         }
                     }
-                    transformer.replaceDeclarationResolvePhaseIfNeeded(property, transformerPhase)
+                    if (property.delegate == null) {
-                    dataFlowAnalyzer.exitProperty(property)?.let {
+                        withNewLocalScope {
-                        property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it))
+                            if (property.receiverTypeRef == null && property.returnTypeRef !is FirImplicitTypeRef) {
+                                context.storeBackingField(property)
+                            }
+                            property.transformAccessors()
+                        }
                     }
-                    property.compose()
                 }
+                transformer.replaceDeclarationResolvePhaseIfNeeded(property, transformerPhase)
+                dataFlowAnalyzer.exitProperty(property)?.let {
+                    property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it))
+                }
+                property.compose()
             }
         }
     }
@@ -183,23 +180,19 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         }
         dataFlowAnalyzer.enterField(field)
         return withFullBodyResolve {
-            withLocalScopeCleanup {
+            context.withTowerDataMode(FirTowerDataMode.CONSTRUCTOR_HEADER) {
-                val primaryConstructorParametersScope = context.getPrimaryConstructorAllParametersScope()
+                context.withContainer(field) {
-                context.withTowerDataMode(FirTowerDataMode.CONSTRUCTOR_HEADER) {
+                    withPrimaryConstructorParameters(includeProperties = true) {
-                    context.withContainer(field) {
+                        field.transformChildren(transformer, withExpectedType(returnTypeRef))
-                        withLocalScopeCleanup {
+                    }
-                            addLocalScope(primaryConstructorParametersScope)
+                    if (field.initializer != null) {
-                            field.transformChildren(transformer, withExpectedType(returnTypeRef))
+                        storeVariableReturnType(field)
-                        }
-                        if (field.initializer != null) {
-                            storeVariableReturnType(field)
-                        }
                     }
                 }
-                transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase)
-                dataFlowAnalyzer.exitField(field)
-                field.compose()
             }
+            transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase)
+            dataFlowAnalyzer.exitField(field)
+            field.compose()
         }
     }
 
@@ -702,11 +695,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         data: ResolutionMode
     ): CompositeTransformResult<FirDeclaration> {
         if (implicitTypeOnly) return anonymousInitializer.compose()
-        return withLocalScopeCleanup {
+        return withPrimaryConstructorParameters(includeProperties = false) {
             dataFlowAnalyzer.enterInitBlock(anonymousInitializer)
-            addLocalScope(
-                context.getPrimaryConstructorPureParametersScope()
-            )
             addNewLocalScope()
             val result =
                 transformDeclarationContent(anonymousInitializer, ResolutionMode.ContextIndependent).single as FirAnonymousInitializer