[Low Level FIR] remove usages of ResolveTreeBuilder as it complicates the code but unused

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

@@ -262,17 +262,15 @@ object LowLevelFirApiFacadeForResolveOnAir {
                 declaration = copiedFirDeclaration,
                 firFile = originalFirFile
             )
-            ResolveTreeBuilder.resolveEnsure(onAirDesignation.declaration, FirResolvePhase.BODY_RESOLVE) {
+            val resolvableSession = onAirDesignation.declaration.llFirResolvableSession
-                val resolvableSession = onAirDesignation.declaration.llFirResolvableSession
+                ?: error("Expected resolvable session")
-                    ?: error("Expected resolvable session")
+            resolvableSession.moduleComponents.firModuleLazyDeclarationResolver
-                resolvableSession.moduleComponents.firModuleLazyDeclarationResolver
+                .runLazyDesignatedOnAirResolveToBodyWithoutLock(
-                    .runLazyDesignatedOnAirResolveToBodyWithoutLock(
+                    designation = onAirDesignation,
-                        designation = onAirDesignation,
+                    checkPCE = true,
-                        checkPCE = true,
+                    onAirCreatedDeclaration = onAirCreatedDeclaration,
-                        onAirCreatedDeclaration = onAirCreatedDeclaration,
+                    towerDataContextCollector = collector,
-                        towerDataContextCollector = collector,
+                )
-                    )
-            }
             copiedFirDeclaration
         }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 
 fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
     designation: Iterator<FirElement>,
@@ -80,13 +79,7 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
             FirLazyBodiesCalculator.calculateLazyBodiesForFunction(it)
         }
 
-        return if (simpleFunction.returnTypeRef is FirResolvedTypeRef) {
+        return super.transformSimpleFunction(simpleFunction, data)
-            super.transformSimpleFunction(simpleFunction, data)
-        } else {
-            return ResolveTreeBuilder.resolveReturnTypeCalculation(simpleFunction) {
-                super.transformSimpleFunction(simpleFunction, data)
-            }
-        }
     }
 
     override fun transformProperty(
@@ -96,12 +89,6 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
         property.processCallable {
             FirLazyBodiesCalculator.calculateLazyBodyForProperty(it)
         }
-        return if (property.returnTypeRef is FirResolvedTypeRef) {
+        return super.transformProperty(property, data)
-            super.transformProperty(property, data)
-        } else {
-            return ResolveTreeBuilder.resolveReturnTypeCalculation(property) {
-                super.transformProperty(property, data)
-            }
-        }
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/LLFirLockProvider.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder
 
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.lockWithPCECheck
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -19,14 +18,12 @@ internal class LLFirLockProvider {
     private val globalLock = ReentrantLock()
 
     inline fun <R> withWriteLock(@Suppress("UNUSED_PARAMETER") key: FirFile, action: () -> R): R {
-        val startTime = System.currentTimeMillis()
+        return globalLock.withLock { action() }
-        return globalLock.withLock { ResolveTreeBuilder.lockNode(startTime, action) }
     }
 
 
     inline fun <R> withWriteLockPCECheck(@Suppress("UNUSED_PARAMETER") key: FirFile, lockingIntervalMs: Long, action: () -> R): R {
-        val startTime = System.currentTimeMillis()
+        return globalLock.lockWithPCECheck(lockingIntervalMs) { action() }
-        return globalLock.lockWithPCECheck(lockingIntervalMs) { ResolveTreeBuilder.lockNode(startTime, action) }
     }
 }
 

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

@@ -132,15 +132,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
             if (toPhase == FirResolvePhase.IMPORTS) return
             if (firFile.resolvePhase >= toPhase) return
             moduleComponents.globalResolveComponents.lockProvider.runCustomResolveUnderLock(firFile, checkPCE) {
-                ResolveTreeBuilder.resolveEnsure(firFile, toPhase) {
+                lazyResolveFileDeclarationWithoutLock(
-                    lazyResolveFileDeclarationWithoutLock(
+                    firFile = firFile,
-                        firFile = firFile,
+                    toPhase = toPhase,
-                        toPhase = toPhase,
+                    collector = collector,
-                        collector = collector,
+                    scopeSession = scopeSession,
-                        scopeSession = scopeSession,
+                    checkPCE = checkPCE,
-                        checkPCE = checkPCE,
+                )
-                    )
-                }
             }
         } catch (e: Throwable) {
             rethrowWithDetails(e, firFile, fromPhase, toPhase)
@@ -345,15 +343,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         }
 
         moduleComponents.globalResolveComponents.lockProvider.runCustomResolveUnderLock(designation.firFile, checkPCE) {
-            ResolveTreeBuilder.resolveEnsure(designation.declaration, neededPhase) {
+            runLazyDesignatedResolveWithoutLock(
-                runLazyDesignatedResolveWithoutLock(
+                designation = designation,
-                    designation = designation,
+                scopeSession = scopeSession,
-                    scopeSession = scopeSession,
+                toPhase = neededPhase,
-                    toPhase = neededPhase,
+                checkPCE = checkPCE,
-                    checkPCE = checkPCE,
+            )
-                )
+            designation.declaration
-                designation.declaration
-            }
         }
     }
 

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

@@ -1,155 +0,0 @@
-/*
- * Copyright 2010-2021 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.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
-import java.io.File
-
-internal object ResolveTreeBuilder {
-
-    private val file: File? by lazy(LazyThreadSafetyMode.PUBLICATION) {
-        System.getProperty("fir.lazy.resolve.dump")?.let {
-            File(it)
-        }
-    }
-
-    class Context(var rootCall: Boolean = true, var underLock: Boolean = false, val builder: StringBuilder = StringBuilder())
-
-    val currentContext: ThreadLocal<Context> = ThreadLocal.withInitial { Context() }
-
-    private fun FirResolvePhase.firPhaseName(): String = when (this) {
-        FirResolvePhase.RAW_FIR -> "Raw"
-        FirResolvePhase.IMPORTS -> "Imports"
-        FirResolvePhase.SUPER_TYPES -> "SuperTypes"
-        FirResolvePhase.TYPES -> "Types"
-        FirResolvePhase.STATUS -> "Status"
-        FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS -> "ArgumentsOfAnnotations"
-        FirResolvePhase.CONTRACTS -> "Contracts"
-        FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> "ImplicitTypes"
-        FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING -> "AnnotationsArgumentsMapping"
-        FirResolvePhase.BODY_RESOLVE -> "Body"
-        else -> "?"
-    }
-
-    fun resolvePhase(
-        declaration: FirDeclaration,
-        phase: FirResolvePhase,
-        body: () -> Unit
-    ) {
-        newNodeContext {
-            resolveToDeclaration(declaration, "Phase", false, phase) {
-                body()
-                declaration
-            }
-        }
-    }
-
-    fun resolveEnsure(
-        declaration: FirDeclaration,
-        phase: FirResolvePhase,
-        body: () -> Unit
-    ) {
-        newNodeContext {
-            resolveToDeclaration(declaration, "Ensure", true, phase) {
-                body()
-                declaration
-            }
-        }
-    }
-
-    inline fun <T> lockNode(startTime: Long, body: () -> T): T {
-        if (file == null) return body()
-        val waitEnd = System.currentTimeMillis()
-        val currentContext = currentContext.get()
-        val builderLength = currentContext.builder.length
-        val wasUnderLock = currentContext.underLock
-        currentContext.underLock = true
-        return newNodeContext {
-            try {
-                body()
-            } finally {
-                val contentionTime = waitEnd - startTime
-                val executionTime = System.currentTimeMillis() - waitEnd
-                if (!wasUnderLock && builderLength != currentContext.builder.length) {
-                    val tag = "<UnderLock waitTime=\"$contentionTime\" executionTime=\"$executionTime\">"
-                    currentContext.builder.insert(builderLength, tag)
-                    currentContext.builder.append("</UnderLock>")
-                }
-                currentContext.underLock = wasUnderLock
-            }
-        }
-    }
-
-    fun <T : FirDeclaration> resolveReturnTypeCalculation(
-        declaration: FirDeclaration,
-        body: () -> T
-    ): T = newNodeContext {
-        resolveToDeclaration(declaration, "RTC", true, null, body)
-    }
-
-    private fun FirDeclaration.toDeclarationName(): String = when (val symbol = symbol) {
-        is FirClassSymbol<*> -> symbol.classId.asSingleFqName().asString()
-        is FirCallableSymbol<*> -> symbol.callableId.asSingleFqName().asString()
-        is FirFileSymbol -> symbol.fir.name
-        else -> symbol::class.qualifiedName
-    } ?: "${this::class.qualifiedName}:${hashCode()}"
-
-    private fun <T : FirDeclaration> resolveToDeclaration(
-        declaration: FirDeclaration,
-        nodeName: String,
-        needWriteDeclarationName: Boolean,
-        phase: FirResolvePhase? = null,
-        body: () -> T
-    ): T {
-        if (phase != null && declaration.resolvePhase >= phase) return body()
-
-        val currentContext = currentContext.get()
-        val currentPosition = currentContext.builder.length
-        var withException = true
-        val start = System.currentTimeMillis()
-        try {
-            return body().also {
-                withException = false
-            }
-        } finally {
-            val end = System.currentTimeMillis()
-            val timeAttr = " time=\"${end - start}\""
-            val phaseAttr = if (phase != null) " phase=\"${phase.firPhaseName()}\"" else ""
-            val declarationAttr = if (needWriteDeclarationName) " declaration=\"${declaration.toDeclarationName()}\"" else ""
-            val exceptionAttr = if (withException) " withException=\"true\"" else ""
-            val nodeContent = "$declarationAttr$phaseAttr$timeAttr$exceptionAttr"
-
-            if (currentPosition == currentContext.builder.length) {
-                currentContext.builder.append("<$nodeName$nodeContent />")
-            } else {
-                currentContext.builder.insert(currentPosition, "<$nodeName$nodeContent>")
-                currentContext.builder.append("</$nodeName>")
-            }
-        }
-    }
-
-    private inline fun <T> newNodeContext(body: () -> T): T {
-        val dumpFile = file ?: return body()
-        val currentContext = currentContext.get()
-        val oldRootEnsure = currentContext.rootCall
-        try {
-            currentContext.rootCall = false
-            return body()
-        } finally {
-            currentContext.rootCall = oldRootEnsure
-            if (oldRootEnsure) {
-                synchronized(dumpFile) {
-                    dumpFile.appendText(currentContext.builder.toString())
-                }
-                currentContext.builder.clear()
-            }
-        }
-    }
-}

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

@@ -7,7 +7,6 @@ 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.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
@@ -39,10 +38,8 @@ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer(
         if (designation.declaration.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return
         designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) {
+            designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-                designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-            }
         }
 
         updatePhaseDeep(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING)

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

@@ -7,7 +7,6 @@ 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.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
@@ -55,11 +54,10 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
 
         val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator()
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
+            moveNextDeclaration(designationIterator)
-                moveNextDeclaration(designationIterator)
-            }
         }
+        
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
         checkIsResolved(designation.declaration)

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

@@ -7,7 +7,6 @@ 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.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -49,10 +48,8 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
 
         val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator()
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) {
+            moveNextDeclaration(designationIterator)
-                moveNextDeclaration(designationIterator)
-            }
         }
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)

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

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTy
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
@@ -54,11 +53,10 @@ internal class LLFirDesignatedBodyResolveTransformer(
         if (designation.declaration.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return
         designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.BODY_RESOLVE) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) {
+            designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-                designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-            }
         }
+    
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true)

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirAbstractContractResolveTransformerDispatcher
@@ -49,12 +48,10 @@ internal class LLFirDesignatedContractsResolveTransformer(
         designation.declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
 
         FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.CONTRACTS) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) {
+            designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-                designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-            }
         }
-
+        
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.CONTRACTS)
         checkIsResolved(designation.declaration)

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

@@ -8,7 +8,6 @@ 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.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirSession
@@ -42,11 +41,10 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
         designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
 
         FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
+            designation.firFile.transform<FirFile, Nothing?>(this, null)
-                designation.firFile.transform<FirFile, Nothing?>(this, null)
-            }
         }
+    
 
         declarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING)

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

@@ -7,7 +7,6 @@ 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.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
@@ -22,10 +21,8 @@ internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) return
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.COMPANION_GENERATION) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPANION_GENERATION) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPANION_GENERATION) {
+            designation.declaration.transform<FirDeclaration, Nothing?>(transformer, null)
-                designation.declaration.transform<FirDeclaration, Nothing?>(transformer, null)
-            }
         }
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPANION_GENERATION)

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

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTy
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
@@ -54,11 +53,10 @@ internal class LLFirDesignatedImplicitTypesTransformer(
         if (designation.declaration.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return
         designation.declaration.checkPhase(FirResolvePhase.CONTRACTS)
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
+            designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-                designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
-            }
         }
+    
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeclarationStatusIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
@@ -42,12 +41,10 @@ internal class LLFirDesignatedStatusResolveTransformer(
         designation.declaration.checkPhase(FirResolvePhase.TYPES)
 
         val transformer = FirDesignatedStatusResolveTransformerForIDE()
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.STATUS) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) {
+            designation.firFile.transform<FirElement, FirResolvedDeclarationStatus?>(transformer, null)
-                designation.firFile.transform<FirElement, FirResolvedDeclarationStatus?>(transformer, null)
-            }
         }
-
+        
         transformer.designationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.STATUS)
         checkIsResolved(designation.declaration)

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

@@ -12,7 +12,6 @@ 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.file.builder.runCustomResolveUnderLock
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirModuleLazyDeclarationResolver
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 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
@@ -145,12 +144,10 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
             FirDeclarationDesignationWithFile(targetPath, resolvableTarget, designation.firFile)
         } else designation
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.SUPER_TYPES) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.SUPER_TYPES) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.SUPER_TYPES) {
+            val collected = collect(targetDesignation)
-                val collected = collect(targetDesignation)
+            supertypeComputationSession.breakLoops(session)
-                supertypeComputationSession.breakLoops(session)
+            apply(collected)
-                apply(collected)
-            }
         }
 
         updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES)

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

@@ -7,7 +7,6 @@ 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.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.*
 import org.jetbrains.kotlin.fir.FirElement
@@ -42,10 +41,8 @@ internal class LLFirDesignatedTypeResolverTransformer(
         if (designation.declaration.resolvePhase >= FirResolvePhase.TYPES) return
         designation.declaration.checkPhase(FirResolvePhase.SUPER_TYPES)
 
-        ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.TYPES) {
+        phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) {
-            phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) {
+            designation.firFile.transform<FirFile, Any?>(this, null)
-                designation.firFile.transform<FirFile, Any?>(this, null)
-            }
         }
 
         declarationTransformer.ensureDesignationPassed()