[LL FIR] move updateDeclarationInternalsPhase checks out of LLFirLazyTransformer

needed for further safe publication of phase update

^KT-56543

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirPhaseUpdater.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2023 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.analysis.low.level.api.fir.lazy.resolve
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+internal object LLFirPhaseUpdater {
+    fun updateDeclarationInternalsPhase(
+        target: FirElementWithResolveState,
+        newPhase: FirResolvePhase,
+        updateForLocalDeclarations: Boolean,
+    ) {
+        if (updateForLocalDeclarations) {
+            PhaseUpdatingTransformer.visitElement(target, newPhase)
+        } else {
+            updatePhaseForNonLocals(target, newPhase)
+        }
+    }
+
+
+    private fun updatePhaseForNonLocals(element: FirElementWithResolveState, newPhase: FirResolvePhase) {
+        if (element.resolvePhase >= newPhase) return
+        element.replaceResolveState(newPhase.asResolveState())
+
+        if (element is FirTypeParameterRefsOwner) {
+            element.typeParameters.forEach { typeParameter ->
+                // if it is not a type parameter of outer declaration
+                if (typeParameter is FirTypeParameter) {
+                    updatePhaseForNonLocals(typeParameter, newPhase)
+                }
+            }
+        }
+
+        when (element) {
+            is FirFunction -> {
+                element.valueParameters.forEach { updatePhaseForNonLocals(it, newPhase) }
+            }
+            is FirProperty -> {
+                element.getter?.let { updatePhaseForNonLocals(it, newPhase) }
+                element.setter?.let { updatePhaseForNonLocals(it, newPhase) }
+            }
+            is FirClass -> {
+                element.declarations.forEach {
+                    updatePhaseForNonLocals(it, newPhase)
+                }
+            }
+            else -> Unit
+        }
+    }
+}
+
+private object PhaseUpdatingTransformer : FirVisitor<Unit, FirResolvePhase>() {
+    override fun visitElement(element: FirElement, data: FirResolvePhase) {
+        if (element is FirElementWithResolveState) {
+            if (element.resolvePhase >= data && element !is FirDefaultPropertyAccessor) return
+            element.replaceResolveState(data.asResolveState())
+        }
+
+        element.acceptChildren(this, data)
+    }
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
@@ -46,8 +46,15 @@ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer(
             FirLazyBodiesCalculator.calculateAnnotations(designation.firFile)
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
+    }
 
-        updatePhaseDeep(designation.target, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING)
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(
+            target,
+            FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING,
+            updateForLocalDeclarations = false,
+        )
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
@@ -63,9 +64,14 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
             moveNextDeclaration(designationIterator)
         }
+    }
 
-
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
-        LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(
+            target,
+            FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS,
+            updateForLocalDeclarations = false,
+        )
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
@@ -55,8 +56,15 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) {
             moveNextDeclaration(designationIterator)
         }
+    }
 
-        LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(
+            target,
+            FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS,
+            updateForLocalDeclarations = false,
+        )
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
@@ -58,9 +58,11 @@ internal class LLFirDesignatedBodyResolveTransformer(
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
 
-
         ideDeclarationTransformer.ensureDesignationPassed()
-        updatePhaseDeep(designation.target, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true)
+    }
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.BODY_RESOLVE, updateForLocalDeclarations = true)
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
@@ -53,7 +53,10 @@ internal class LLFirDesignatedContractsResolveTransformer(
         }
 
         ideDeclarationTransformer.ensureDesignationPassed()
-        updatePhaseDeep(designation.target, FirResolvePhase.CONTRACTS)
+    }
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.CONTRACTS, updateForLocalDeclarations = false)
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
@@ -50,9 +50,15 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
             designation.firFile.transform<FirFile, Nothing?>(this, null)
         }
 
-
         declarationTransformer.ensureDesignationPassed()
-        updatePhaseDeep(designation.target, FirResolvePhase.EXPECT_ACTUAL_MATCHING)
+    }
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(
+            target,
+            FirResolvePhase.EXPECT_ACTUAL_MATCHING,
+            updateForLocalDeclarations = false,
+        )
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -26,8 +27,10 @@ internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPANION_GENERATION) {
             designation.target.transform<FirDeclaration, Nothing?>(transformer, null)
         }
+    }
 
-        LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPANION_GENERATION)
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.COMPANION_GENERATION, updateForLocalDeclarations = false)
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
@@ -62,9 +62,15 @@ internal class LLFirDesignatedImplicitTypesTransformer(
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
 
-
         ideDeclarationTransformer.ensureDesignationPassed()
-        updatePhaseDeep(designation.target, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+    }
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(
+            target,
+            FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE,
+            updateForLocalDeclarations = false/* here should be true if we resolved the body*/,
+        )
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeclarationStatusIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
@@ -85,8 +85,10 @@ internal class LLFirDesignatedStatusResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) {
             transformer.moveNextDeclaration()
         }
+    }
 
-        updatePhaseDeep(designation.target, FirResolvePhase.STATUS)
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.STATUS, updateForLocalDeclarations = false)
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt

@@ -10,8 +10,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
@@ -159,11 +159,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
         designation.firFile.checkPhase(FirResolvePhase.IMPORTS)
 
         val targetDesignation = if (designation.target !is FirClassLikeDeclaration) {
-            val resolvableTarget = designation.path.lastOrNull()
+            val resolvableTarget = designation.path.lastOrNull() ?: return
-            if (resolvableTarget == null) {
-                updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES)
-                return
-            }
             val targetPath = designation.path.dropLast(1)
             FirDesignationWithFile(targetPath, resolvableTarget, designation.firFile)
         } else designation
@@ -173,8 +169,10 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
             supertypeComputationSession.breakLoops(session)
             apply(collected)
         }
+    }
 
-        updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES)
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.SUPER_TYPES, updateForLocalDeclarations = false)
     }
 
     override fun checkIsResolved(target: FirElementWithResolveState) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReceiverTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
@@ -53,7 +53,10 @@ internal class LLFirDesignatedTypeResolverTransformer(
         }
 
         declarationTransformer.ensureDesignationPassed()
-        updatePhaseDeep(designation.target, FirResolvePhase.TYPES)
+    }
+
+    override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
+        LLFirPhaseUpdater.updateDeclarationInternalsPhase(target, FirResolvePhase.TYPES, updateForLocalDeclarations = false)
     }
 
     override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirResolvedTypeRef {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt

@@ -7,17 +7,16 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
-import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 internal interface LLFirLazyTransformer {
     fun transformDeclaration(phaseRunner: LLFirPhaseRunner)
 
     fun checkIsResolved(target: FirElementWithResolveState)
 
+    fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState)
+
     fun checkNestedDeclarationsAreResolved(target: FirElementWithResolveState) {
         if (target !is FirDeclaration) return
         checkFunctionParametersAreResolved(target)
@@ -61,65 +60,13 @@ internal interface LLFirLazyTransformer {
     }
 
     companion object {
-        private object WholeTreePhaseUpdater : FirVisitor<Unit, FirResolvePhase>() {
-            override fun visitElement(element: FirElement, data: FirResolvePhase) {
-                if (element is FirElementWithResolveState) {
-                    if (element.resolvePhase >= data && element !is FirDefaultPropertyAccessor) return
-
-                    @OptIn(ResolveStateAccess::class)
-                    element.resolveState = data.asResolveState()
-                }
-
-                element.acceptChildren(this, data)
-            }
-        }
-
-        private fun updatePhaseForNonLocals(element: FirElementWithResolveState, newPhase: FirResolvePhase) {
-            if (element.resolvePhase >= newPhase) return
-
-            @OptIn(ResolveStateAccess::class)
-            element.resolveState = newPhase.asResolveState()
-
-            if (element is FirTypeParameterRefsOwner) {
-                element.typeParameters.forEach { typeParameter ->
-                    // if it is not a type parameter of outer declaration
-                    if (typeParameter is FirTypeParameter) {
-                        updatePhaseForNonLocals(typeParameter, newPhase)
-                    }
-                }
-            }
-
-            when (element) {
-                is FirFunction -> {
-                    element.valueParameters.forEach { updatePhaseForNonLocals(it, newPhase) }
-                }
-                is FirProperty -> {
-                    element.getter?.let { updatePhaseForNonLocals(it, newPhase) }
-                    element.setter?.let { updatePhaseForNonLocals(it, newPhase) }
-                }
-                is FirClass -> {
-                    element.declarations.forEach {
-                        updatePhaseForNonLocals(it, newPhase)
-                    }
-                }
-                else -> Unit
-            }
-        }
-
-        fun updatePhaseDeep(element: FirElementWithResolveState, newPhase: FirResolvePhase, withNonLocalDeclarations: Boolean = false) {
-            if (withNonLocalDeclarations) {
-                WholeTreePhaseUpdater.visitElement(element, newPhase)
-            } else {
-                updatePhaseForNonLocals(element, newPhase)
-            }
-        }
-
         internal var needCheckingIfClassMembersAreResolved: Boolean = false
             @TestOnly set
 
         val DUMMY = object : LLFirLazyTransformer {
             override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {}
             override fun checkIsResolved(target: FirElementWithResolveState) {}
+            override fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {}
         }
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt

@@ -32,6 +32,7 @@ internal class LLFirLazyTransformerExecutor {
 
             lockProvider.withLock(designation.firFile) {
                 lazyTransformer.transformDeclaration(phaseRunner)
+                lazyTransformer.updatePhaseForDeclarationInternals(designation.target)
                 lazyTransformer.checkIsResolved(designation.target)
             }
         }