[LL FIR] encapsulate FileAnnotationContainer resolution logic

As a file annotation container is required for resolution,
it should be closer to the resolution logic. Now only LLFirTargetResolver
will operate this logic, so we can change the logic in the future without
a big refactoring.
E.g., as the next step, this resolution can be integrated to the file

^KT-63042

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirClassWithAllCallablesResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirSingleResolveTarget
@@ -24,13 +23,13 @@ internal object LLFirResolveMultiDesignationCollector {
         is FirFile -> listOf(LLFirSingleResolveTarget(target))
         is FirSyntheticPropertyAccessor -> getDesignationsToResolve(target.delegate)
         is FirSyntheticProperty -> getDesignationsToResolve(target.getter) + target.setter?.let(::getDesignationsToResolve).orEmpty()
-        else -> getMainDesignationToResolve(target)?.withAnnotationContainer()
-    } ?: emptyList()
+        else -> listOfNotNull(getMainDesignationToResolve(target))
+    }
 
     fun getDesignationsToResolveWithCallableMembers(target: FirRegularClass): List<LLFirResolveTarget> {
         val designation = target.tryCollectDesignationWithFile() ?: return emptyList()
         val resolveTarget = LLFirClassWithAllCallablesResolveTarget(designation.firFile, designation.path, target)
-        return resolveTarget.withAnnotationContainer()
+        return listOf(resolveTarget)
     }
 
     fun getDesignationsToResolveRecursively(target: FirElementWithResolveState): List<LLFirResolveTarget> {
@@ -39,16 +38,7 @@ internal object LLFirResolveMultiDesignationCollector {
         if (!target.shouldBeResolved()) return emptyList()
         val designation = target.tryCollectDesignationWithFile() ?: return emptyList()
         val resolveTarget = LLFirWholeElementResolveTarget(designation.firFile, designation.path, target)
-        return resolveTarget.withAnnotationContainer()
-    }
-
-    private fun LLFirResolveTarget.withAnnotationContainer(): List<LLFirResolveTarget> {
-        val annotationsContainer = firFile.annotationsContainer
-        if (annotationsContainer?.shouldBeResolved() != true) return listOf(this)
-        return buildList {
-            add(annotationsContainer.collectDesignationWithFile().asResolveTarget())
-            add(this@withAnnotationContainer)
-        }
+        return listOf(resolveTarget)
     }
 
     private fun getMainDesignationToResolve(target: FirElementWithResolveState): LLFirResolveTarget? {

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

@@ -9,10 +9,12 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
+import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 
 internal abstract class LLFirTargetResolver(
     protected val resolveTarget: LLFirResolveTarget,
@@ -24,17 +26,6 @@ internal abstract class LLFirTargetResolver(
 
     val nestedClassesStack: List<FirRegularClass> get() = _nestedClassesStack.toList()
 
-    /**
-     * Must be executed without a lock
-     */
-    private fun resolveFileAnnotationContainerIfNeeded(elementWithResolveState: FirElementWithResolveState) {
-        if (elementWithResolveState !is FirFile) return
-        val annotationContainer = elementWithResolveState.annotationsContainer ?: return
-        withFile(elementWithResolveState) {
-            performResolve(annotationContainer)
-        }
-    }
-
     /**
      * @see resolveDependencyTarget
      */
@@ -49,7 +40,8 @@ internal abstract class LLFirTargetResolver(
     private fun resolveDependencyTarget(target: FirElementWithResolveState) {
         if (skipDependencyTargetResolutionStep) return
 
-        resolveFileAnnotationContainerIfNeeded(target)
+        if (target is FirFileAnnotationsContainer) return
+        resolveTarget.firFile.annotationsContainer?.lazyResolveToPhase(resolverPhase)
     }
 
     override fun withFile(firFile: FirFile, action: () -> Unit) {