[FIR IDE] Remove typed fir designation

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/FirDesignationState.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.idea.fir.low.level.api
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 
-abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationUntypedDesignation) {
+abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationDesignation) {
     private var context: C? = null
     private val designationState = FirDesignationState(designation)
 
@@ -36,7 +36,7 @@ abstract class ContextByDesignationCollector<C : Any>(private val designation: F
     }
 }
 
-private class FirDesignationState(val designation: FirDeclarationUntypedDesignation) {
+private class FirDesignationState(val designation: FirDeclarationDesignation) {
     /**
      * Holds current declaration index
      * if `currentIndex in [0, designation.path.lastIndex]` then current declaration is in path

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/FirDeclarationDesignation.kt

@@ -12,15 +12,12 @@ import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClass
 
-typealias FirDeclarationUntypedDesignation = FirDeclarationDesignation<FirDeclaration>
+class FirDeclarationDesignationWithFile(
-typealias FirDeclarationUntypedDesignationWithFile = FirDeclarationDesignationWithFile<FirDeclaration>
-
-class FirDeclarationDesignationWithFile<out T : FirDeclaration>(
     path: List<FirDeclaration>,
-    declaration: T,
+    declaration: FirDeclaration,
     isLocalDesignation: Boolean,
     val firFile: FirFile
-) : FirDeclarationDesignation<T>(
+) : FirDeclarationDesignation(
     path,
     declaration,
     isLocalDesignation
@@ -32,9 +29,9 @@ class FirDeclarationDesignationWithFile<out T : FirDeclaration>(
     }
 }
 
-open class FirDeclarationDesignation<out T : FirDeclaration>(
+open class FirDeclarationDesignation(
     val path: List<FirDeclaration>,
-    val declaration: T,
+    val declaration: FirDeclaration,
     val isLocalDesignation: Boolean
 ) {
     fun toSequence(includeTarget: Boolean): Sequence<FirDeclaration> = sequence {
@@ -92,12 +89,12 @@ private fun FirRegularClass.collectForLocal(): List<FirClassLikeDeclaration<*>>
 }
 
 
-fun FirDeclaration.collectDesignation(firFile: FirFile): FirDeclarationUntypedDesignationWithFile =
+fun FirDeclaration.collectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile =
     collectDesignationAndIsLocal(this).let {
-        FirDeclarationUntypedDesignationWithFile(it.first, this, it.second, firFile)
+        FirDeclarationDesignationWithFile(it.first, this, it.second, firFile)
     }
 
-fun FirDeclaration.collectDesignation(): FirDeclarationUntypedDesignation =
+fun FirDeclaration.collectDesignation(): FirDeclarationDesignation =
     collectDesignationAndIsLocal(this).let {
-        FirDeclarationUntypedDesignation(it.first, this, it.second)
+        FirDeclarationDesignation(it.first, this, it.second)
     }

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

@@ -265,7 +265,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
                 }
             } ?: newDeclarationWithReplacement
 
-            val onAirDesignation = FirDeclarationUntypedDesignationWithFile(
+            val onAirDesignation = FirDeclarationDesignationWithFile(
                 path = originalDesignation.path,
                 declaration = copiedFirDeclaration,
                 isLocalDesignation = false,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt

@@ -12,12 +12,12 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
 import org.jetbrains.kotlin.idea.fir.low.level.api.ContextByDesignationCollector
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDesignation
 
 private class ContextCollectingDiagnosticCollectorVisitor private constructor(
     sessionHolder: SessionHolder,
-    designation: FirDeclarationUntypedDesignationWithFile,
+    designation: FirDeclarationDesignationWithFile,
 ) : AbstractDiagnosticCollectorVisitor(
     PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(sessionHolder)
 ) {
@@ -40,7 +40,7 @@ private class ContextCollectingDiagnosticCollectorVisitor private constructor(
     override fun checkElement(element: FirElement) {}
 
     companion object {
-        fun collect(sessionHolder: SessionHolder, designation: FirDeclarationUntypedDesignationWithFile): PersistentCheckerContext {
+        fun collect(sessionHolder: SessionHolder, designation: FirDeclarationDesignationWithFile): PersistentCheckerContext {
             val visitor = ContextCollectingDiagnosticCollectorVisitor(sessionHolder, designation)
             designation.firFile.accept(visitor, null)
             return visitor.contextCollector.getCollectedContext()

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyBodiesCalculator.kt

@@ -14,38 +14,25 @@ import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 
 internal object FirLazyBodiesCalculator {
-    fun calculateLazyBodiesInside(designation: FirDeclarationUntypedDesignation) {
+    fun calculateLazyBodiesInside(designation: FirDeclarationDesignation) {
         designation.declaration.transform<FirElement, MutableList<FirDeclaration>>(
             FirLazyBodiesCalculatorTransformer,
             designation.toSequence(includeTarget = true).toMutableList()
         )
     }
 
-    fun calculateLazyBodiesInsideIfNeeded(designation: FirDeclarationUntypedDesignation, phase: FirResolvePhase) {
-        if (phase == FIRST_PHASE_WHICH_NEEDS_BODIES) {
-            calculateLazyBodiesInside(designation)
-        }
-    }
-
-    fun calculateLazyBodiesIfPhaseRequires(firFile: FirFile, phase: FirResolvePhase) {
-        if (phase == FIRST_PHASE_WHICH_NEEDS_BODIES) {
-            firFile.transform<FirElement, MutableList<FirDeclaration>>(FirLazyBodiesCalculatorTransformer, mutableListOf())
-        }
-    }
-
     fun calculateLazyBodies(firFile: FirFile) {
         firFile.transform<FirElement, MutableList<FirDeclaration>>(FirLazyBodiesCalculatorTransformer, mutableListOf())
     }
 
-    fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation<FirSimpleFunction>) {
+    fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation) {
-        val simpleFunction = designation.declaration
+        val simpleFunction = designation.declaration as FirSimpleFunction
         if (simpleFunction.body !is FirLazyBlock) return
         val newFunction = RawFirNonLocalDeclarationBuilder.buildWithRebind(
             session = simpleFunction.moduleData.session,
@@ -59,9 +46,9 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
-    fun calculateLazyBodyForSecondaryConstructor(designation: FirDeclarationDesignation<FirConstructor>) {
+    fun calculateLazyBodyForSecondaryConstructor(designation: FirDeclarationDesignation) {
         require(!designation.isLocalDesignation) { "Not supported for local designations" }
-        val secondaryConstructor = designation.declaration
+        val secondaryConstructor = designation.declaration as FirConstructor
         require(!secondaryConstructor.isPrimary)
         if (secondaryConstructor.body !is FirLazyBlock) return
 
@@ -77,9 +64,9 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
-    fun calculateLazyBodyForProperty(designation: FirDeclarationDesignation<FirProperty>) {
+    fun calculateLazyBodyForProperty(designation: FirDeclarationDesignation) {
         require(!designation.isLocalDesignation) { "Not supported for local designations" }
-        val firProperty = designation.declaration
+        val firProperty = designation.declaration as FirProperty
         if (!needCalculatingLazyBodyForProperty(firProperty)) return
 
         val newProperty = RawFirNonLocalDeclarationBuilder.buildWithRebind(
@@ -117,8 +104,6 @@ internal object FirLazyBodiesCalculator {
                 || firProperty.setter?.body is FirLazyBlock
                 || firProperty.initializer is FirLazyExpression
                 || (firProperty.delegate as? FirWrappedDelegateExpression)?.expression is FirLazyExpression
-
-    private val FIRST_PHASE_WHICH_NEEDS_BODIES = FirResolvePhase.CONTRACTS
 }
 
 private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<FirDeclaration>>() {

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt

@@ -244,7 +244,7 @@ internal class FirLazyDeclarationResolver(
     }
 
     private fun runLazyDesignatedResolveWithoutLock(
-        designation: FirDeclarationUntypedDesignationWithFile,
+        designation: FirDeclarationDesignationWithFile,
         moduleFileCache: ModuleFileCache,
         scopeSession: ScopeSession,
         toPhase: FirResolvePhase,
@@ -272,7 +272,6 @@ internal class FirLazyDeclarationResolver(
             currentPhase = currentPhase.next
             if (currentPhase.pluginPhase) continue
             if (checkPCE) checkCanceled()
-            FirLazyBodiesCalculator.calculateLazyBodiesInsideIfNeeded(designation, currentPhase)
 
             currentPhase.createLazyTransformer(
                 designation = designation,
@@ -287,7 +286,7 @@ internal class FirLazyDeclarationResolver(
     }
 
     internal fun runLazyDesignatedOnAirResolveToBodyWithoutLock(
-        designation: FirDeclarationUntypedDesignationWithFile,
+        designation: FirDeclarationDesignationWithFile,
         moduleFileCache: ModuleFileCache,
         checkPCE: Boolean,
         resolveWithUnchangedFir: Boolean,
@@ -322,7 +321,7 @@ internal class FirLazyDeclarationResolver(
     }
 
     private fun FirResolvePhase.createLazyTransformer(
-        designation: FirDeclarationUntypedDesignationWithFile,
+        designation: FirDeclarationDesignationWithFile,
         scopeSession: ScopeSession,
         declarationPhaseDowngraded: Boolean,
         moduleFileCache: ModuleFileCache,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider
 import org.jetbrains.kotlin.idea.util.ifTrue
@@ -32,7 +32,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
         fun buildWithReplacement(
             session: FirSession,
             scopeProvider: FirScopeProvider,
-            designation: FirDeclarationUntypedDesignation,
+            designation: FirDeclarationDesignation,
             rootNonLocalDeclaration: KtDeclaration,
             replacement: RawFirReplacement?
         ): FirDeclaration {
@@ -54,7 +54,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
         fun buildWithRebind(
             session: FirSession,
             scopeProvider: FirScopeProvider,
-            designation: FirDeclarationUntypedDesignation,
+            designation: FirDeclarationDesignation,
             rootNonLocalDeclaration: KtDeclaration,
         ): FirDeclaration {
             require(!designation.isLocalDesignation) { "Local declaration is not allowed here" }

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedBodyResolveTransformerForIDE.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.*
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.isResolvedForAllDeclarations
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.updateResolvedPhaseForDeclarationAndChildren
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.isTargetCallableDeclarat
  * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children
  */
 internal class FirDesignatedBodyResolveTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedContractsResolveTransformerForIDE.kt

@@ -12,7 +12,8 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.isResolvedForAllDeclarations
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.updateResolvedPhaseForDeclarationAndChildren
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.*
@@ -22,7 +23,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePhase
  * Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children
  */
 internal class FirDesignatedContractsResolveTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,
@@ -54,6 +55,7 @@ internal class FirDesignatedContractsResolveTransformerForIDE(
         if (designation.isTargetCallableDeclarationAndInPhase(FirResolvePhase.CONTRACTS)) return
         designation.ensureDesignation(FirResolvePhase.STATUS)
 
+        FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) {
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedImplicitTypesTransformerForIDE.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyRe
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.isResolvedForAllDeclarations
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.updateResolvedPhaseForDeclarationAndChildren
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.isTargetCallableDeclarat
  * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents
  */
 internal class FirDesignatedImplicitTypesTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedStatusResolveTransformerForIDE.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.isResolvedForAllDeclarations
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.updateResolvedPhaseForDeclarationAndChildren
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureDesignation
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePhase
  * Transform designation into STATUS phase. Affects only for designation, target declaration, it's children and dependents
  */
 internal class FirDesignatedStatusResolveTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     private val session: FirSession,
     private val scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedSupertypeResolverTransformerForIDE.kt

@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.fir.resolve.transformers.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.toSymbol
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyDeclarationResolver
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePhase
  * Transform designation into SUPER_TYPES phase. Affects only for designation, target declaration, it's children and dependents
  */
 internal class FirDesignatedSupertypeResolverTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     private val session: FirSession,
     private val scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,
@@ -41,7 +41,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
 
     private val supertypeComputationSession = SupertypeComputationSession()
 
-    private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDeclarationUntypedDesignation) :
+    private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDeclarationDesignation) :
         FirSupertypeResolverVisitor(
             session = session,
             supertypeComputationSession = supertypeComputationSession,
@@ -60,7 +60,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
         }
     }
 
-    private inner class DesignatedFirApplySupertypesTransformer(classDesignation: FirDeclarationUntypedDesignation) :
+    private inner class DesignatedFirApplySupertypesTransformer(classDesignation: FirDeclarationDesignation) :
         FirApplySupertypesTransformer(supertypeComputationSession) {
 
         override fun needReplacePhase(firDeclaration: FirDeclaration): Boolean =
@@ -93,9 +93,9 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
         }
     }
 
-    private fun collect(designation: FirDeclarationUntypedDesignationWithFile): Collection<FirDeclarationUntypedDesignationWithFile> {
+    private fun collect(designation: FirDeclarationDesignationWithFile): Collection<FirDeclarationDesignationWithFile> {
-        val visited = mutableMapOf<FirDeclaration, FirDeclarationUntypedDesignationWithFile>()
+        val visited = mutableMapOf<FirDeclaration, FirDeclarationDesignationWithFile>()
-        val toVisit = mutableListOf<FirDeclarationUntypedDesignationWithFile>()
+        val toVisit = mutableListOf<FirDeclarationDesignationWithFile>()
         toVisit.add(designation)
 
         while (toVisit.isNotEmpty()) {
@@ -131,8 +131,8 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
         return visited.values
     }
 
-    private fun apply(visited: Collection<FirDeclarationUntypedDesignationWithFile>) {
+    private fun apply(visited: Collection<FirDeclarationDesignationWithFile>) {
-        fun applyToFileSymbols(designations: List<FirDeclarationUntypedDesignationWithFile>) {
+        fun applyToFileSymbols(designations: List<FirDeclarationDesignationWithFile>) {
             for (designation in designations) {
                 if (checkPCE) checkCanceled()
                 val applier = DesignatedFirApplySupertypesTransformer(designation)
@@ -159,7 +159,7 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
             val resolvableTarget = designation.path.lastOrNull() ?: return
             check(resolvableTarget is FirClassLikeDeclaration<*>)
             val targetPath = designation.path.dropLast(1)
-            FirDeclarationUntypedDesignationWithFile(targetPath, resolvableTarget, false, designation.firFile)
+            FirDeclarationDesignationWithFile(targetPath, resolvableTarget, false, designation.firFile)
         } else designation
 
         if (targetDesignation.isResolvedForAllDeclarations(FirResolvePhase.SUPER_TYPES, declarationPhaseDowngraded)) return

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirDesignatedTypeResolverTransformerForIDE.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.isResolvedForAllDeclarations
 import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.updateResolvedPhaseForDeclarationAndChildren
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.*
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePhaseForClasses
  * Transform designation into TYPES phase. Affects only for designation, target declaration and it's children
  */
 internal class FirDesignatedTypeResolverTransformerForIDE(
-    private val designation: FirDeclarationUntypedDesignationWithFile,
+    private val designation: FirDeclarationDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     private val declarationPhaseDowngraded: Boolean,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/FirLazyTransformerForIDE.kt

@@ -9,7 +9,7 @@ import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 
 internal interface FirLazyTransformerForIDE {
     fun transformDeclaration(phaseRunner: FirPhaseRunner)
@@ -47,7 +47,7 @@ internal interface FirLazyTransformerForIDE {
             }
         }
 
-        fun FirDeclarationUntypedDesignation.resolvePhaseForAllDeclarations(includeDeclarationPhase: Boolean): FirResolvePhase {
+        fun FirDeclarationDesignation.resolvePhaseForAllDeclarations(includeDeclarationPhase: Boolean): FirResolvePhase {
             //resolvePhaseWithForAllDeclarations for these origins are derived from original declaration
             val includeTarget = when (declaration.origin) {
                 is FirDeclarationOrigin.SubstitutionOverride,
@@ -63,7 +63,7 @@ internal interface FirLazyTransformerForIDE {
             return if (includeDeclarationPhase) minOf(declaration.resolvePhase, allContaining) else allContaining
         }
 
-        fun FirDeclarationUntypedDesignation.isResolvedForAllDeclarations(phase: FirResolvePhase, includeDeclarationPhase: Boolean) =
+        fun FirDeclarationDesignation.isResolvedForAllDeclarations(phase: FirResolvePhase, includeDeclarationPhase: Boolean) =
             resolvePhaseForAllDeclarations(includeDeclarationPhase) >= phase
 
         val DUMMY = object : FirLazyTransformerForIDE {

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/transformers/IDEDeclarationTransformer.kt

@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractPhaseTransformer
 import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 
-internal class IDEDeclarationTransformer(private val designation: FirDeclarationUntypedDesignation) {
+internal class IDEDeclarationTransformer(private val designation: FirDeclarationDesignation) {
     private val designationWithoutTargetIterator = designation.toSequence(includeTarget = false).iterator()
     private var isInsideTargetDeclaration: Boolean = false
     private var designationPassed: Boolean = false

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/util/firDeclarationDesignationUtils.kt

@@ -8,21 +8,21 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.util
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 
 internal fun FirDeclaration.ensurePhase(firResolvePhase: FirResolvePhase) =
     check(resolvePhase >= firResolvePhase) {
         "Element phase required to be $firResolvePhase but element resolved to $resolvePhase"
     }
 
-internal fun FirDeclarationUntypedDesignation.ensurePathPhase(firResolvePhase: FirResolvePhase) =
+internal fun FirDeclarationDesignation.ensurePathPhase(firResolvePhase: FirResolvePhase) =
     path.forEach { it.ensurePhase(firResolvePhase) }
 
-internal fun FirDeclarationUntypedDesignation.ensureDesignation(firResolvePhase: FirResolvePhase) {
+internal fun FirDeclarationDesignation.ensureDesignation(firResolvePhase: FirResolvePhase) {
     ensurePathPhase(firResolvePhase)
     declaration.ensurePhase(firResolvePhase)
 }
-internal fun FirDeclarationUntypedDesignation.ensurePhaseForClasses(firResolvePhase: FirResolvePhase) {
+internal fun FirDeclarationDesignation.ensurePhaseForClasses(firResolvePhase: FirResolvePhase) {
     ensurePathPhase(firResolvePhase)
     if (declaration is FirClassLikeDeclaration<*>) {
         check(declaration.resolvePhase >= firResolvePhase) {
@@ -31,7 +31,7 @@ internal fun FirDeclarationUntypedDesignation.ensurePhaseForClasses(firResolvePh
     }
 }
 
-internal fun FirDeclarationUntypedDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean =
+internal fun FirDeclarationDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean =
     (declaration as? FirCallableDeclaration<*>)?.let { it.resolvePhase >= firResolvePhase } ?: false
 
-internal fun FirDeclarationUntypedDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull()
+internal fun FirDeclarationDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull()

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirLazyBodiesCalculatorTest.kt

@@ -28,7 +28,7 @@ abstract class AbstractFirLazyBodiesCalculatorTest : KotlinLightCodeInsightFixtu
         val provider = session.firIdeProvider.kotlinScopeProvider
 
         val laziedFirFile = RawFirBuilder(session, provider, RawFirBuilderMode.LAZY_BODIES).buildFirFile(file)
-        FirLazyBodiesCalculator.calculateLazyBodiesIfPhaseRequires(laziedFirFile, FirResolvePhase.CONTRACTS)
+        FirLazyBodiesCalculator.calculateLazyBodies(laziedFirFile)
         val fullFirFile = RawFirBuilder(session, provider, RawFirBuilderMode.NORMAL).buildFirFile(file)
 
         val laziedFirFileDump = StringBuilder().also { FirRenderer(it).visitFile(laziedFirFile) }.toString()

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractPartialRawFirBuilderTestCase.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.RawFirNonLocalDeclarationBuilder
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
@@ -62,7 +62,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : KtParsingTestCase(
 
     private class DesignationBuilder(private val elementToBuild: KtDeclaration) : FirVisitorVoid() {
         private val path = mutableListOf<FirDeclaration>()
-        var resultDesignation: FirDeclarationUntypedDesignation? = null
+        var resultDesignation: FirDeclarationDesignation? = null
             private set
 
         override fun visitElement(element: FirElement) {