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 62686f8..f3ac751 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
@@ -22,7 +22,6 @@
 import org.jetbrains.kotlin.fir.resolve.calls.*
 import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext
 import org.jetbrains.kotlin.fir.resolve.inference.FirInferenceSession
-import org.jetbrains.kotlin.fir.resolve.inference.FirPCLAInferenceSession
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.withScopeCleanup
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -39,12 +38,9 @@
 import org.jetbrains.kotlin.util.PrivateForInline
 
 class BodyResolveContext(
-    val returnTypeCalculator: ReturnTypeCalculator,
+    @set:PrivateForInline
+    var returnTypeCalculator: ReturnTypeCalculator,
     val dataFlowAnalyzerContext: DataFlowAnalyzerContext,
-    val targetedLocalClasses: Set<FirClassLikeDeclaration> = emptySet(),
-    val outerLocalClassForNested: MutableMap<FirClassLikeSymbol<*>, FirClassLikeSymbol<*>> = mutableMapOf(),
-    // If `this` context is defined for some local class
-    val parentContext: BodyResolveContext? = null
 ) {
     val fileImportsScope: MutableList<FirScope> = mutableListOf()
 
@@ -85,53 +81,17 @@
     val containerIfAny: FirDeclaration?
         get() = containers.lastOrNull()
 
-    // Potentially, we might just initialize it with null and make the `inferenceSession` getter look like
-    // _inferenceSession ?: parentContext?.inferenceSession ?: FirInferenceSession.DEFAULT.
-    // But that might lead to poor performance in the most common case.
-    @Suppress("PropertyName")
-    @PrivateForInline
-    var _inferenceSession: FirInferenceSession? =
-        when {
-            parentContext == null -> FirInferenceSession.DEFAULT
-            else -> null
-        }
-
-    val inferenceSession: FirInferenceSession
-        @OptIn(PrivateForInline::class)
-        get() = _inferenceSession
-        // It's important that we re-use the session from the parent context.
-        // As in different moments the value might be restored _there_ (in the parent context)
-        // while it wouldn't be reflected if we just copied it once at the creation of the local-class-context.
-        //
-        // It's only important for the case like
-        // pclaBuilder {
-        //    object {
-        //       var implicitlyTypedDelegatedVar by delegate()
-        //
-        //    }
-        //    ...
-        // }
-        //
-        // There we would resolve the setter and relevant `setValue` call only after the whole `pclaBuilder` call is completed
-        // So, the relevant PCLA session would be dead at the moment and the default one would be set back
-        // for the `parentContext!!.inferenceSession`.
-        //
-        // NB: Looks like we should use this session only for PCLA to be able
-        // to use information from local class inside it.
-        // However, we should not use other kinds of inference sessions,
-        // otherwise we can "inherit" type variables from there provoking inference problems
-            ?: parentContext!!.inferenceSession as? FirPCLAInferenceSession
-            ?: FirInferenceSession.DEFAULT
-
+    @set:PrivateForInline
+    var inferenceSession: FirInferenceSession = FirInferenceSession.DEFAULT
 
     @OptIn(PrivateForInline::class)
     inline fun <R, S : FirInferenceSession> withInferenceSession(inferenceSession: S, block: S.() -> R): R {
-        val oldSession = this._inferenceSession
-        this._inferenceSession = inferenceSession
+        val oldSession = this.inferenceSession
+        this.inferenceSession = inferenceSession
         return try {
             inferenceSession.block()
         } finally {
-            this._inferenceSession = oldSession
+            this.inferenceSession = oldSession
         }
     }
 
@@ -171,6 +131,11 @@
 
     var containingClassDeclarations: ArrayDeque<FirClass> = ArrayDeque()
 
+    @set:PrivateForInline
+    var targetedLocalClasses: Set<FirClassLikeDeclaration> = emptySet()
+
+    val outerLocalClassForNested: MutableMap<FirClassLikeSymbol<*>, FirClassLikeSymbol<*>> = mutableMapOf()
+
     @OptIn(PrivateForInline::class)
     inline fun <T> withTowerDataContexts(newContexts: FirRegularTowerDataContexts, f: () -> T): T {
         val old = regularTowerDataContexts
@@ -438,23 +403,36 @@
     }
 
     @OptIn(PrivateForInline::class)
-    fun createSnapshotForLocalClasses(
+    inline fun <T> forLocalClasses(
         returnTypeCalculator: ReturnTypeCalculator,
-        targetedLocalClasses: Set<FirClassLikeDeclaration>
-    ): BodyResolveContext =
-        BodyResolveContext(
-            returnTypeCalculator, dataFlowAnalyzerContext, targetedLocalClasses, outerLocalClassForNested,
-            parentContext = this,
-        ).apply {
-            file = this@BodyResolveContext.file
-            fileImportsScope += this@BodyResolveContext.fileImportsScope
-            specialTowerDataContexts.putAll(this@BodyResolveContext.specialTowerDataContexts)
-            containers = this@BodyResolveContext.containers
-            containingClassDeclarations = ArrayDeque(this@BodyResolveContext.containingClassDeclarations)
-            containingRegularClass = this@BodyResolveContext.containingRegularClass
-            replaceTowerDataContext(this@BodyResolveContext.towerDataContext)
-            anonymousFunctionsAnalyzedInDependentContext.addAll(this@BodyResolveContext.anonymousFunctionsAnalyzedInDependentContext)
+        targetedLocalClasses: Set<FirClassLikeDeclaration>,
+        f: () -> T,
+    ): T {
+        val oldReturnTypeCalculator = this.returnTypeCalculator
+        val oldTargetedLocalClasses = this.targetedLocalClasses
+        return try {
+            this.returnTypeCalculator = returnTypeCalculator
+            this.targetedLocalClasses = targetedLocalClasses
+            f()
+        } finally {
+            this.returnTypeCalculator = oldReturnTypeCalculator
+            this.targetedLocalClasses = oldTargetedLocalClasses
         }
+    }
+
+    @OptIn(PrivateForInline::class)
+    inline fun <T> withReturnTypeCalculator(
+        returnTypeCalculator: ReturnTypeCalculator,
+        f: () -> T,
+    ): T {
+        val oldReturnTypeCalculator = this.returnTypeCalculator
+        return try {
+            this.returnTypeCalculator = returnTypeCalculator
+            f()
+        } finally {
+            this.returnTypeCalculator = oldReturnTypeCalculator
+        }
+    }
 
     // withElement PUBLIC API
 
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 237f1ff..2341b6b 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
@@ -95,23 +95,22 @@
         implicitBodyResolveComputationSession,
         designationMap,
         outerTransformer = components.transformer,
+        outerBodyResolveContext = components.context,
     )
 
-    val newContext = components.context.createSnapshotForLocalClasses(returnTypeCalculator, targetedClasses)
-    returnTypeCalculator.outerBodyResolveContext = newContext
+    return components.context.forLocalClasses(returnTypeCalculator, targetedClasses) {
+        runContractResolveForLocalClass(components.session, components.scopeSession, components.context)
 
-    runContractResolveForLocalClass(components.session, components.scopeSession, components.context, targetedClasses)
-
-    val transformer = FirImplicitAwareBodyResolveTransformer(
-        components.session, components.scopeSession,
-        implicitBodyResolveComputationSession,
-        FirResolvePhase.BODY_RESOLVE,
-        implicitTypeOnly = false,
-        returnTypeCalculator,
-        outerBodyResolveContext = newContext,
-    )
-
-    return this.transform(transformer, resolutionMode)
+        val transformer = FirImplicitAwareBodyResolveTransformer(
+            components.session, components.scopeSession,
+            implicitBodyResolveComputationSession,
+            FirResolvePhase.BODY_RESOLVE,
+            implicitTypeOnly = false,
+            returnTypeCalculator,
+            outerBodyResolveContext = components.context,
+        )
+        this.transform(transformer, resolutionMode)
+    }
 }
 
 open class FirImplicitAwareBodyResolveTransformer(
@@ -194,17 +193,12 @@
     val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
     val designationMapForLocalClasses: Map<FirCallableDeclaration, List<FirClassLikeDeclaration>> = mapOf(),
     val outerTransformer: FirAbstractBodyResolveTransformerDispatcher? = null,
+    val outerBodyResolveContext: BodyResolveContext? = null
 ) : ReturnTypeCalculator() {
     override val callableCopyTypeCalculator: CallableCopyTypeCalculator = CallableCopyTypeCalculatorWithJump()
 
     @OptIn(PrivateForInline::class)
-    var outerBodyResolveContext: BodyResolveContext? = null
-        set(context) {
-            field = context
-            outerTowerDataContexts = context?.regularTowerDataContexts
-        }
-
-    var outerTowerDataContexts: FirRegularTowerDataContexts? = null
+    val outerTowerDataContexts: FirRegularTowerDataContexts? = outerBodyResolveContext?.regularTowerDataContexts
 
     override fun tryCalculateReturnTypeOrNull(declaration: FirCallableDeclaration): FirResolvedTypeRef {
         // Local declarations must be handled by `ReturnTypeCalculatorForFullBodyResolve` to avoid resolution cycles in LL FIR.
diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt
index 6d4d7a2..e3be875 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt
@@ -45,16 +45,14 @@
 fun <F : FirClassLikeDeclaration> F.runContractResolveForLocalClass(
     session: FirSession,
     scopeSession: ScopeSession,
-    outerBodyResolveContext: BodyResolveContext,
-    targetedClasses: Set<FirClassLikeDeclaration>
+    context: BodyResolveContext
 ): F {
-    val newContext = outerBodyResolveContext.createSnapshotForLocalClasses(
+    return context.withReturnTypeCalculator(
         ReturnTypeCalculatorForFullBodyResolve.Contract,
-        targetedClasses
-    )
-    val transformer = FirContractResolveTransformer(session, scopeSession, newContext)
-
-    return this.transformSingle(transformer, ResolutionMode.ContextIndependent)
+    ) {
+        val transformer = FirContractResolveTransformer(session, scopeSession, context)
+        this.transformSingle(transformer, ResolutionMode.ContextIndependent)
+    }
 }
 
 fun <F : FirFunction> F.runContractResolveForFunction(