[FIR IDE] Rename and move refactorings, codereview refactorings

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

@@ -6,11 +6,9 @@
 package org.jetbrains.kotlin.idea.fir.low.level.api
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
 
-abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationDesignation) {
+abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationUntypedDesignation) {
     private var context: C? = null
     private val designationState = FirDesignationState(designation)
 
@@ -38,7 +36,7 @@ abstract class ContextByDesignationCollector<C : Any>(private val designation: F
     }
 }
 
-private class FirDesignationState(val designation: FirDeclarationDesignation) {
+private class FirDesignationState(val designation: FirDeclarationUntypedDesignation) {
     /**
      * 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/DeclarationCopyBuilder.kt

@@ -166,7 +166,7 @@ internal object DeclarationCopyBuilder {
         return RawFirNonLocalDeclarationBuilder.buildWithReplacement(
             session = originalFirDeclaration.moduleData.session,
             baseScopeProvider = originalFirDeclaration.moduleData.session.firIdeProvider.kotlinScopeProvider,
-            designation = originalFirDeclaration.collectDesignation().path,
+            designation = originalFirDeclaration.collectDesignation(),
             declarationToBuild = rootNonLocalDeclaration,
             replacement = replacement,
         ) as D

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

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

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

@@ -31,7 +31,7 @@ abstract class FirModuleResolveState {
 
     /**
      * Build fully resolved FIR node for requested element.
-     * This operation could be performance affective, use
+     * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase, use
      * @see tryGetCachedFirFile to get [FirFile] in undefined phase
      */
     internal abstract fun getOrBuildFirFor(element: KtElement): FirElement

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

@@ -113,14 +113,14 @@ fun <D : FirDeclaration, R> D.withFirDeclarationInWriteLock(
 
 /**
  * Returns a list of Diagnostics compiler finds for given [KtElement]
- * This operation could be performance affective
+ * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 fun KtElement.getDiagnostics(resolveState: FirModuleResolveState, filter: DiagnosticCheckerFilter): Collection<FirPsiDiagnostic<*>> =
     resolveState.getDiagnostics(this, filter)
 
 /**
  * Returns a list of Diagnostics compiler finds for given [KtFile]
- * This operation could be performance affective
+ * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 fun KtFile.collectDiagnosticsForFile(
     resolveState: FirModuleResolveState,
@@ -143,7 +143,7 @@ fun <D : FirDeclaration> D.resolvedFirToPhase(
 /**
  * Get a [FirElement] which was created by [KtElement]
  * Returned [FirElement] is guaranteed to be resolved to [FirResolvePhase.BODY_RESOLVE] phase
- * This operation could be performance affective
+ * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 fun KtElement.getOrBuildFir(
     resolveState: FirModuleResolveState,
@@ -152,7 +152,7 @@ fun KtElement.getOrBuildFir(
 /**
  * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], `null` otherwise
  * Returned [FirElement] is guaranteed to be resolved to [FirResolvePhase.BODY_RESOLVE] phase
- * This operation could be performance affective
+ * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
     resolveState: FirModuleResolveState,
@@ -161,7 +161,7 @@ inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
 /**
  * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], throws [InvalidFirElementTypeException] otherwise
  * Returned [FirElement] is guaranteed to be resolved to [FirResolvePhase.BODY_RESOLVE] phase
- * This operation could be performance affective
+ * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
  */
 inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
     resolveState: FirModuleResolveState,

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

@@ -12,13 +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.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDesignation
 
 private class ContextCollectingDiagnosticCollectorVisitor private constructor(
     sessionHolder: SessionHolder,
-    designation: FirDeclarationDesignationWithFile,
+    designation: FirDeclarationUntypedDesignationWithFile,
 ) : AbstractDiagnosticCollectorVisitor(
     PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(sessionHolder)
 ) {
@@ -41,7 +40,7 @@ private class ContextCollectingDiagnosticCollectorVisitor private constructor(
     override fun checkElement(element: FirElement) {}
 
     companion object {
-        fun collect(sessionHolder: SessionHolder, designation: FirDeclarationDesignationWithFile): PersistentCheckerContext {
+        fun collect(sessionHolder: SessionHolder, designation: FirDeclarationUntypedDesignationWithFile): 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/element/builder/FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyBodiesCalculator
 
 fun FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator(
@@ -41,7 +42,7 @@ fun FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator(
 }
 
 class FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
-    private val designation: List<FirElement>,
+    designation: List<FirElement>,
     session: FirSession,
     scopeSession: ScopeSession,
     implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
@@ -61,17 +62,20 @@ class FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
         simpleFunction: FirSimpleFunction,
         data: ResolutionMode
     ): FirSimpleFunction {
-        FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, declarationDesignation)
+        val firDesignation = FirDeclarationDesignation(declarationDesignation, simpleFunction, false)
+        FirLazyBodiesCalculator.calculateLazyBodiesForFunction(firDesignation)
         return super.transformSimpleFunction(simpleFunction, data)
     }
 
     override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirDeclaration {
-        FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, declarationDesignation)
+        val firDesignation = FirDeclarationDesignation(declarationDesignation, constructor, false)
+        FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(firDesignation)
         return super.transformConstructor(constructor, data)
     }
 
     override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
-        FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, declarationDesignation)
+        val firDesignation = FirDeclarationDesignation(declarationDesignation, property, false)
+        FirLazyBodiesCalculator.calculateLazyBodyForProperty(firDesignation)
         return super.transformProperty(property, data)
     }
 }

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

@@ -14,13 +14,14 @@ 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: FirDeclarationDesignation) {
+    fun calculateLazyBodiesInside(designation: FirDeclarationUntypedDesignation) {
         designation.declaration.transform<FirElement, MutableList<FirDeclaration>>(
             FirLazyBodiesCalculatorTransformer,
             designation.toSequence(includeTarget = true).toMutableList()
@@ -33,7 +34,9 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
-    fun calculateLazyBodiesForFunction(simpleFunction: FirSimpleFunction, designation: List<FirDeclaration>) {
+    fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation<FirSimpleFunction>) {
+        require(!designation.isLocalDesignation) { "Not supported for local designations" }
+        val simpleFunction = designation.declaration
         if (simpleFunction.body !is FirLazyBlock) return
         val newFunction = RawFirNonLocalDeclarationBuilder.build(
             session = simpleFunction.moduleData.session,
@@ -47,7 +50,9 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
-    fun calculateLazyBodyForSecondaryConstructor(secondaryConstructor: FirConstructor, designation: List<FirDeclaration>) {
+    fun calculateLazyBodyForSecondaryConstructor(designation: FirDeclarationDesignation<FirConstructor>) {
+        require(!designation.isLocalDesignation) { "Not supported for local designations" }
+        val secondaryConstructor = designation.declaration
         require(!secondaryConstructor.isPrimary)
         if (secondaryConstructor.body !is FirLazyBlock) return
 
@@ -63,7 +68,9 @@ internal object FirLazyBodiesCalculator {
         }
     }
 
-    fun calculateLazyBodyForProperty(firProperty: FirProperty, designation: List<FirDeclaration>) {
+    fun calculateLazyBodyForProperty(designation: FirDeclarationDesignation<FirProperty>) {
+        require(!designation.isLocalDesignation) { "Not supported for local designations" }
+        val firProperty = designation.declaration
         if (!needCalculatingLazyBodyForProperty(firProperty)) return
 
         val newProperty = RawFirNonLocalDeclarationBuilder.build(
@@ -131,7 +138,8 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<F
         data: MutableList<FirDeclaration>
     ): FirDeclaration {
         if (simpleFunction.body is FirLazyBlock) {
-            FirLazyBodiesCalculator.calculateLazyBodiesForFunction(simpleFunction, data)
+            val designation = FirDeclarationDesignation(data, simpleFunction, false)
+            FirLazyBodiesCalculator.calculateLazyBodiesForFunction(designation)
         }
         return simpleFunction
     }
@@ -141,14 +149,16 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<MutableList<F
         data: MutableList<FirDeclaration>
     ): FirDeclaration {
         if (constructor.body is FirLazyBlock) {
-            FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(constructor, data)
+            val designation = FirDeclarationDesignation(data, constructor, false)
+            FirLazyBodiesCalculator.calculateLazyBodyForSecondaryConstructor(designation)
         }
         return constructor
     }
 
     override fun transformProperty(property: FirProperty, data: MutableList<FirDeclaration>): FirDeclaration {
         if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) {
-            FirLazyBodiesCalculator.calculateLazyBodyForProperty(property, data)
+            val designation = FirDeclarationDesignation(data, property, false)
+            FirLazyBodiesCalculator.calculateLazyBodyForProperty(designation)
         }
         return property
     }

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

@@ -15,8 +15,8 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.collectDesignation
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.getNonLocalContainingOrThisDeclaration
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder
@@ -137,7 +137,7 @@ internal class FirLazyDeclarationResolver(
         }
     }
 
-    private fun createLazyBodiesCalculator(designation: FirDeclarationDesignation): (FirResolvePhase) -> Unit {
+    private fun createLazyBodiesCalculator(designation: FirDeclarationUntypedDesignation): (FirResolvePhase) -> Unit {
         var calculated = false
         return { phase: FirResolvePhase ->
             if (!calculated && phase >= FirResolvePhase.CONTRACTS) {
@@ -308,7 +308,7 @@ internal class FirLazyDeclarationResolver(
     private fun runLazyResolvePhase(
         phase: FirResolvePhase,
         scopeSession: ScopeSession,
-        designation: FirDeclarationDesignationWithFile,
+        designation: FirDeclarationUntypedDesignationWithFile,
         towerDataContextCollector: FirTowerDataContextCollector?,
         firProviderInterceptor: FirProviderInterceptor?
     ) {
@@ -327,7 +327,7 @@ internal class FirLazyDeclarationResolver(
     }
 
     private fun FirResolvePhase.createLazyTransformer(
-        designation: FirDeclarationDesignationWithFile,
+        designation: FirDeclarationUntypedDesignationWithFile,
         scopeSession: ScopeSession,
         towerDataContextCollector: FirTowerDataContextCollector?,
         firProviderInterceptor: FirProviderInterceptor?,
@@ -338,7 +338,7 @@ internal class FirLazyDeclarationResolver(
             scopeSession,
             firProviderInterceptor,
         )
-        FirResolvePhase.SEALED_CLASS_INHERITORS -> FirLazyTransformerForIDE.EMPTY
+        FirResolvePhase.SEALED_CLASS_INHERITORS -> FirLazyTransformerForIDE.DUMMY
         FirResolvePhase.TYPES -> FirDesignatedTypeResolverTransformerForIDE(
             designation,
             designation.firFile.moduleData.session,

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

@@ -14,6 +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.psi.*
 
 internal data class RawFirReplacement<T : KtElement>(val from: T, val to: T)
@@ -45,10 +46,11 @@ internal class RawFirNonLocalDeclarationBuilder<T : KtElement> private construct
         fun <T : KtElement> buildWithReplacement(
             session: FirSession,
             baseScopeProvider: FirScopeProvider,
-            designation: List<FirDeclaration>,
+            designation: FirDeclarationUntypedDesignation,
             declarationToBuild: KtDeclaration,
             replacement: RawFirReplacement<T>? = null
         ): FirDeclaration {
+
             if (replacement != null) {
                 require(elementIsApplicable(replacement.from)) {
                     "Build with replacement is possible for applicable type but given ${replacement.from::class.simpleName}"
@@ -61,7 +63,7 @@ internal class RawFirNonLocalDeclarationBuilder<T : KtElement> private construct
             val builder = RawFirNonLocalDeclarationBuilder(session, baseScopeProvider, declarationToBuild, replacement)
             builder.context.packageFqName = declarationToBuild.containingKtFile.packageFqName
 
-            val result = builder.moveNext(designation.iterator(), containingClass = null)
+            val result = builder.moveNext(designation.path.iterator(), containingClass = null)
             check(replacement == null || builder.replacementApplied) {
                 "Replacement requested but was not applied for ${replacement!!.from::class.simpleName}"
             }
@@ -71,12 +73,12 @@ internal class RawFirNonLocalDeclarationBuilder<T : KtElement> private construct
         fun build(
             session: FirSession,
             baseScopeProvider: FirScopeProvider,
-            designation: List<FirDeclaration>,
+            designation: FirDeclarationUntypedDesignation,
             rootNonLocalDeclaration: KtDeclaration
         ): FirDeclaration {
             val builder = RawFirNonLocalDeclarationBuilder<KtElement>(session, baseScopeProvider, rootNonLocalDeclaration)
             builder.context.packageFqName = rootNonLocalDeclaration.containingKtFile.packageFqName
-            return builder.moveNext(designation.iterator(), containingClass = null)
+            return builder.moveNext(designation.path.iterator(), containingClass = null)
         }
     }
 

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

@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 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.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhase
 
 internal class FirDesignatedBodyResolveTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     towerDataContextCollector: FirTowerDataContextCollector? = null,

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

@@ -11,11 +11,11 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 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.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhase
 
 internal class FirDesignatedContractsResolveTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
 ) : FirLazyTransformerForIDE, FirContractResolveTransformer(session, scopeSession) {

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

@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 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.api.FirDeclarationDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirIdeDesignatedBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhase
 
 internal class FirDesignatedImplicitTypesTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
     towerDataContextCollector: FirTowerDataContextCollector? = null,

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

@@ -13,12 +13,13 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirDesignatedStatusResolveT
 import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession
 import org.jetbrains.kotlin.fir.visitors.transformSingle
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensurePathPhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.targetContainingDeclaration
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePathPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhase
 
 internal class FirDesignatedStatusResolveTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     private val session: FirSession,
     private val scopeSession: ScopeSession,
 ) : FirLazyTransformerForIDE {
@@ -62,7 +63,7 @@ internal class FirDesignatedStatusResolveTransformerForIDE(
         designation.ensurePathPhase(FirResolvePhase.TYPES)
         designation.ensureTargetPhase(FirResolvePhase.TYPES)
 
-        val containingClass = designation.path.lastOrNull()
+        val containingClass = designation.targetContainingDeclaration()
         if (containingClass == null) {
             resolveTopLevelDeclaration(designation.declaration)
         } else {

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

@@ -13,12 +13,12 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirApplySupertypesTransform
 import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSupertypeResolverVisitor
 import org.jetbrains.kotlin.fir.resolve.transformers.SupertypeComputationSession
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensurePathPhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhaseIfClass
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePathPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhaseIfClass
 
 internal class FirDesignatedSupertypeResolverTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     private val session: FirSession,
     private val scopeSession: ScopeSession,
     private val firProviderInterceptor: FirProviderInterceptor?
@@ -43,4 +43,4 @@ internal class FirDesignatedSupertypeResolverTransformerForIDE(
         designation.declaration.transform<FirElement, Void?>(applySupertypesTransformer, null)
         designation.ensureTargetPhaseIfClass(FirResolvePhase.SUPER_TYPES)
     }
-}
+}

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

@@ -8,17 +8,15 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.transformers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignationWithFile
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensurePathPhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhase
-import org.jetbrains.kotlin.idea.fir.low.level.api.transformers.FirLazyTransformerForIDE.Companion.ensureTargetPhaseIfClass
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignationWithFile
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensurePathPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhase
+import org.jetbrains.kotlin.idea.fir.low.level.api.util.ensureTargetPhaseIfClass
 
 internal class FirDesignatedTypeResolverTransformerForIDE(
-    private val designation: FirDeclarationDesignationWithFile,
+    private val designation: FirDeclarationUntypedDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
 ) : FirLazyTransformerForIDE, FirTypeResolveTransformer(session, scopeSession) {

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

@@ -5,32 +5,12 @@
 
 package org.jetbrains.kotlin.idea.fir.low.level.api.transformers
 
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
-
 internal interface FirLazyTransformerForIDE {
     fun transformDeclaration()
 
     companion object {
-        val EMPTY = object : FirLazyTransformerForIDE {
+        val DUMMY = object : FirLazyTransformerForIDE {
             override fun transformDeclaration() = Unit
         }
-
-        fun FirDeclarationDesignation.ensurePathPhase(firResolvePhase: FirResolvePhase) {
-            toSequence(includeTarget = false).forEach { firDeclaration ->
-                check(firDeclaration.resolvePhase >= firResolvePhase) {
-                    "Designation element phase required to be $firResolvePhase but element resolved to ${firDeclaration.resolvePhase}"
-                }
-            }
-        }
-
-        fun FirDeclarationDesignation.ensureTargetPhase(firResolvePhase: FirResolvePhase) =
-            check(declaration.resolvePhase >= firResolvePhase) { "Expected $firResolvePhase but found ${declaration.resolvePhase}" }
-
-        fun FirDeclarationDesignation.ensureTargetPhaseIfClass(firResolvePhase: FirResolvePhase) = when (declaration) {
-            is FirProperty, is FirSimpleFunction -> Unit
-            is FirClass<*>, is FirTypeAlias -> ensureTargetPhase(firResolvePhase)
-            else -> error("Unexpected target")
-        }
     }
 }

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

@@ -9,11 +9,12 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractPhaseTransformer
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationDesignation
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
 
-internal class IDEDeclarationTransformer(private val designation: FirDeclarationDesignation) {
+internal class IDEDeclarationTransformer(private val designation: FirDeclarationUntypedDesignation) {
     private val designationWithoutTargetIterator = designation.toSequence(includeTarget = false).iterator()
     private var isInsideTargetDeclaration: Boolean = false
+    private var designationPassed: Boolean = false
 
     inline fun <K, D> transformDeclarationContent(
         transformer: FirAbstractPhaseTransformer<D>,
@@ -21,11 +22,12 @@ internal class IDEDeclarationTransformer(private val designation: FirDeclaration
         data: D,
         defaultCallTransform: () -> K
     ): K {
-
+        //It means that we are inside the target declaration
         if (isInsideTargetDeclaration) {
             return defaultCallTransform()
         }
 
+        //It means that we already transform target declaration and now can skip all others
         if (designationPassed) {
             return declaration
         }
@@ -46,7 +48,6 @@ internal class IDEDeclarationTransformer(private val designation: FirDeclaration
     }
 
     val needReplacePhase: Boolean get() = isInsideTargetDeclaration
-    private var designationPassed: Boolean = false
 
     fun ensureDesignationPassed() {
         check(designationPassed) { "Designation not passed for declaration ${designation.declaration::class.simpleName}" }

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

@@ -0,0 +1,28 @@
+/*
+ * 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.idea.fir.low.level.api.util
+
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirDeclarationUntypedDesignation
+
+internal fun FirDeclarationUntypedDesignation.ensurePathPhase(firResolvePhase: FirResolvePhase) {
+    toSequence(includeTarget = false).forEach { firDeclaration ->
+        check(firDeclaration.resolvePhase >= firResolvePhase) {
+            "Designation element phase required to be $firResolvePhase but element resolved to ${firDeclaration.resolvePhase}"
+        }
+    }
+}
+
+internal fun FirDeclarationUntypedDesignation.ensureTargetPhase(firResolvePhase: FirResolvePhase) =
+    check(declaration.resolvePhase >= firResolvePhase) { "Expected $firResolvePhase but found ${declaration.resolvePhase}" }
+
+internal fun FirDeclarationUntypedDesignation.ensureTargetPhaseIfClass(firResolvePhase: FirResolvePhase) = when (declaration) {
+    is FirProperty, is FirSimpleFunction -> Unit
+    is FirClass<*>, is FirTypeAlias -> ensureTargetPhase(firResolvePhase)
+    else -> error("Unexpected target")
+}
+
+internal fun FirDeclarationUntypedDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull()

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

@@ -17,6 +17,8 @@ import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 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.lazy.resolve.RawFirNonLocalDeclarationBuilder
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.psi.*
@@ -58,26 +60,26 @@ abstract class AbstractPartialRawFirBuilderTestCase : KtParsingTestCase(
     }
 
     private class DesignationBuilder(private val elementToBuild: KtDeclaration) : FirVisitorVoid() {
-        val designation = mutableListOf<FirDeclaration>()
-        var originalDeclaration: FirDeclaration? = null
-        var built = false
+        private val path = mutableListOf<FirDeclaration>()
+        var resultDesignation: FirDeclarationUntypedDesignation? = null
+            private set
 
         override fun visitElement(element: FirElement) {
-            if (built) return
+            if (resultDesignation != null) return
             when (element) {
                 is FirSimpleFunction, is FirProperty -> {
                     if (element.psi == elementToBuild) {
-                        originalDeclaration = element as FirDeclaration
-                        built = true
+                        val originalDeclaration = element as FirDeclaration
+                        resultDesignation = FirDeclarationDesignation(path, originalDeclaration, false)
                     } else {
                         element.acceptChildren(this)
                     }
                 }
                 is FirRegularClass -> {
-                    designation.add(element)
+                    path.add(element)
                     element.acceptChildren(this)
-                    if (!built) {
-                        designation.removeLast()
+                    if (resultDesignation == null) {
+                        path.removeLast()
                     }
                 }
                 else -> {
@@ -114,10 +116,10 @@ abstract class AbstractPartialRawFirBuilderTestCase : KtParsingTestCase(
                 klass: FirClass<*>,
                 useSiteSession: FirSession,
                 scopeSession: ScopeSession
-            ): FirScope? =
+            ): FirScope =
                 error("Should not be called")
 
-            override fun getNestedClassifierScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope? =
+            override fun getNestedClassifierScope(klass: FirClass<*>, useSiteSession: FirSession, scopeSession: ScopeSession): FirScope =
                 error("Should not be called")
         }
 
@@ -127,12 +129,13 @@ abstract class AbstractPartialRawFirBuilderTestCase : KtParsingTestCase(
 
         val designationBuilder = DesignationBuilder(elementToBuild)
         original.accept(designationBuilder)
-        TestCase.assertTrue(designationBuilder.built)
+        val designation = designationBuilder.resultDesignation
+        TestCase.assertTrue(designation != null)
 
         val firElement = RawFirNonLocalDeclarationBuilder.build(
             session,
             scopeProvider,
-            designationBuilder.designation,
+            designation!!,
             elementToBuild
         )