[FIR][tree] replace FirDeclaration.resolvePhase -> resolveState

Lazy resolve state represents the lazy resolve
state of the current declaration
It can be either resolved or be in a process of resolve

^KT-56543

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/firAnnotationUtils.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.fir.symbols.resolvedAnnotationsWithClassIds
 import org.jetbrains.kotlin.fir.symbols.resolvedCompilerRequiredAnnotations
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 internal fun mapAnnotationParameters(annotation: FirAnnotation): Map<Name, FirExpression> {
     if (annotation is FirAnnotationCall && annotation.arguments.isEmpty()) return emptyMap()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeAndAnnotations.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 internal fun FirClassSymbol<*>.superTypesList(builder: KtSymbolByFirBuilder): List<KtType> =
     resolvedSuperTypeRefs.mapToKtType(builder)
@@ -39,7 +39,7 @@ internal fun FirCallableSymbol<*>.returnType(builder: KtSymbolByFirBuilder): KtT
     builder.typeBuilder.buildKtType(resolvedReturnType)
 
 internal fun FirCallableSymbol<*>.receiver(builder: KtSymbolByFirBuilder): KtReceiverParameterSymbol? =
-        builder.callableBuilder.buildExtensionReceiverSymbol(this)
+    builder.callableBuilder.buildExtensionReceiverSymbol(this)
 
 internal fun FirCallableSymbol<*>.receiverType(builder: KtSymbolByFirBuilder): KtType? =
     resolvedReceiverTypeRef?.let { receiver ->

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 
 abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDesignation) {
     private var context: C? = null
     private val designationState = FirDesignationState(designation)
 
     protected abstract fun getCurrentContext(): C
-    protected abstract fun goToNestedDeclaration(target: FirElementWithResolvePhase)
+    protected abstract fun goToNestedDeclaration(target: FirElementWithResolveState)
 
     fun getCollectedContext(): C {
         return context
@@ -48,14 +48,14 @@ private class FirDesignationState(val designation: FirDesignation) {
 
     fun canGoNext(): Boolean = currentIndex < designation.path.size
 
-    val currentDeclarationIfPresent: FirElementWithResolvePhase?
+    val currentDeclarationIfPresent: FirElementWithResolveState?
         get() = when (currentIndex) {
             in designation.path.indices -> designation.path[currentIndex]
             designation.path.size -> designation.target
             else -> null
         }
 
-    val currentDeclaration: FirElementWithResolvePhase
+    val currentDeclaration: FirElementWithResolveState
         get() = currentDeclarationIfPresent
             ?: errorWithFirSpecificEntries("Went inside target declaration")
 

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

@@ -28,13 +28,13 @@ import org.jetbrains.kotlin.name.ClassId
 
 class FirDesignationWithFile(
     path: List<FirRegularClass>,
-    target: FirElementWithResolvePhase,
+    target: FirElementWithResolveState,
     val firFile: FirFile
 ) : FirDesignation(
     path,
     target,
 ) {
-    fun toSequenceWithFile(includeTarget: Boolean): Sequence<FirElementWithResolvePhase> = sequence {
+    fun toSequenceWithFile(includeTarget: Boolean): Sequence<FirElementWithResolveState> = sequence {
         yield(firFile)
         yieldAll(path)
         if (includeTarget) yield(target)
@@ -43,18 +43,18 @@ class FirDesignationWithFile(
 
 open class FirDesignation(
     val path: List<FirRegularClass>,
-    val target: FirElementWithResolvePhase,
+    val target: FirElementWithResolveState,
 ) {
-    val firstNonFileDeclaration: FirElementWithResolvePhase
+    val firstNonFileDeclaration: FirElementWithResolveState
         get() = path.firstOrNull() ?: target
 
-    fun toSequence(includeTarget: Boolean): Sequence<FirElementWithResolvePhase> = sequence {
+    fun toSequence(includeTarget: Boolean): Sequence<FirElementWithResolveState> = sequence {
         yieldAll(path)
         if (includeTarget) yield(target)
     }
 }
 
-private fun collectDesignationPath(target: FirElementWithResolvePhase): List<FirRegularClass>? {
+private fun collectDesignationPath(target: FirElementWithResolveState): List<FirRegularClass>? {
     when (target) {
         is FirSimpleFunction,
         is FirProperty,
@@ -214,34 +214,34 @@ private fun findKotlinStdlibClass(classId: ClassId, target: FirDeclaration): Fir
     return FirElementFinder.findClassifierWithClassId(firFile, classId) as? FirRegularClass
 }
 
-fun FirElementWithResolvePhase.collectDesignation(firFile: FirFile): FirDesignationWithFile =
+fun FirElementWithResolveState.collectDesignation(firFile: FirFile): FirDesignationWithFile =
     tryCollectDesignation(firFile) ?: buildErrorWithAttachment("No designation of local declaration") {
         withFirEntry("firFile", firFile)
     }
 
-fun FirElementWithResolvePhase.collectDesignation(): FirDesignation =
+fun FirElementWithResolveState.collectDesignation(): FirDesignation =
     tryCollectDesignation()
         ?: buildErrorWithAttachment("No designation of local declaration") {
             withFirEntry("FirDeclaration", this@collectDesignation)
         }
 
-fun FirElementWithResolvePhase.collectDesignationWithFile(): FirDesignationWithFile =
+fun FirElementWithResolveState.collectDesignationWithFile(): FirDesignationWithFile =
     tryCollectDesignationWithFile()
         ?: buildErrorWithAttachment("No designation of local declaration") {
             withFirEntry("FirDeclaration", this@collectDesignationWithFile)
         }
 
-fun FirElementWithResolvePhase.tryCollectDesignation(firFile: FirFile): FirDesignationWithFile? =
+fun FirElementWithResolveState.tryCollectDesignation(firFile: FirFile): FirDesignationWithFile? =
     collectDesignationPath(this)?.let {
         FirDesignationWithFile(it, this, firFile)
     }
 
-fun FirElementWithResolvePhase.tryCollectDesignation(): FirDesignation? =
+fun FirElementWithResolveState.tryCollectDesignation(): FirDesignation? =
     collectDesignationPath(this)?.let {
         FirDesignation(it, this)
     }
 
-fun FirElementWithResolvePhase.tryCollectDesignationWithFile(): FirDesignationWithFile? {
+fun FirElementWithResolveState.tryCollectDesignationWithFile(): FirDesignationWithFile? {
     return when (this) {
         is FirScript, is FirFileAnnotationsContainer -> {
             val firFile = getContainingFile() ?: return null
@@ -252,6 +252,6 @@ fun FirElementWithResolvePhase.tryCollectDesignationWithFile(): FirDesignationWi
             val firFile = getContainingFile() ?: return null
             FirDesignationWithFile(path, this, firFile)
         }
-        else -> unexpectedElementError<FirElementWithResolvePhase>(this)
+        else -> unexpectedElementError<FirElementWithResolveState>(this)
     }
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.ContextByDesignationColle
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContextForProvider
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
 import org.jetbrains.kotlin.fir.containingClass
@@ -26,7 +26,7 @@ private class ContextCollectingDiagnosticCollectorVisitor private constructor(
     private val contextCollector = object : ContextByDesignationCollector<CheckerContextForProvider>(designation) {
         override fun getCurrentContext(): CheckerContextForProvider = context
 
-        override fun goToNestedDeclaration(target: FirElementWithResolvePhase) {
+        override fun goToNestedDeclaration(target: FirElementWithResolveState) {
             target.accept(this@ContextCollectingDiagnosticCollectorVisitor, null)
         }
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureElement.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -123,10 +123,13 @@ internal class ReanalyzableFunctionStructureElement(
                 with(originalFunction) {
                     replaceBody(temporaryFunction.body)
                     replaceContractDescription(temporaryFunction.contractDescription)
-                    replaceResolvePhase(upgradedPhase)
+                    @OptIn(ResolveStateAccess::class)
+                    resolveState = upgradedPhase.asResolveState()
                 }
+
                 designation.toSequence(includeTarget = true).forEach {
-                    it.replaceResolvePhase(minOf(it.resolvePhase, upgradedPhase))
+                    @OptIn(ResolveStateAccess::class)
+                    it.resolveState = minOf(it.resolvePhase, upgradedPhase).asResolveState()
                 }
 
                 originalFunction.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
@@ -169,13 +172,14 @@ internal class ReanalyzablePropertyStructureElement(
             val upgradedPhase = minOf(originalProperty.resolvePhase, getterPhase, setterPhase, FirResolvePhase.DECLARATIONS)
 
             withInvalidationOnException(moduleComponents.session) {
+                @OptIn(ResolveStateAccess::class)
                 with(originalProperty) {
                     getter?.replaceBody(temporaryProperty.getter?.body)
                     setter?.replaceBody(temporaryProperty.setter?.body)
                     replaceInitializer(temporaryProperty.initializer)
-                    getter?.replaceResolvePhase(upgradedPhase)
-                    setter?.replaceResolvePhase(upgradedPhase)
-                    replaceResolvePhase(upgradedPhase)
+                    getter?.resolveState = upgradedPhase.asResolveState()
+                    setter?.resolveState = upgradedPhase.asResolveState()
+                    resolveState = upgradedPhase.asResolveState()
                     replaceBodyResolveState(FirPropertyBodyResolveState.NOTHING_RESOLVED)
                 }
 

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

@@ -44,7 +44,7 @@ internal object FirLazyBodiesCalculator {
         firFile.transform<FirElement, PersistentList<FirRegularClass>>(FirLazyBodiesCalculatorTransformer, persistentListOf())
     }
 
-    fun calculateAnnotations(firElement: FirElementWithResolvePhase) {
+    fun calculateAnnotations(firElement: FirElementWithResolveState) {
         calculateAnnotations(firElement, firElement.moduleData.session)
     }
 
@@ -55,7 +55,7 @@ internal object FirLazyBodiesCalculator {
         )
     }
 
-    fun calculateCompilerAnnotations(firElement: FirElementWithResolvePhase) {
+    fun calculateCompilerAnnotations(firElement: FirElementWithResolveState) {
         firElement.transform<FirElement, FirLazyAnnotationTransformerData>(
             FirLazyAnnotationTransformer,
             FirLazyAnnotationTransformerData(firElement.moduleData.session, FirLazyAnnotationTransformerScope.COMPILER_ONLY)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
 import org.jetbrains.kotlin.analysis.utils.errors.rethrowExceptionWithDetails
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
@@ -58,13 +58,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         }
     }
 
-    private fun FirElementWithResolvePhase.isValidForResolve() = when (this) {
+    private fun FirElementWithResolveState.isValidForResolve() = when (this) {
         is FirDeclaration -> isValidForResolve()
         is FirFileAnnotationsContainer -> true
         else -> throwUnexpectedFirElementError(this)
     }
 
-    private fun resolveContainingFileToImports(target: FirElementWithResolvePhase) {
+    private fun resolveContainingFileToImports(target: FirElementWithResolveState) {
         if (target.resolvePhase >= FirResolvePhase.IMPORTS) return
         val firFile = target.getContainingFile() ?: return
         if (firFile.resolvePhase >= FirResolvePhase.IMPORTS) return
@@ -77,7 +77,8 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         if (firFile.resolvePhase >= FirResolvePhase.IMPORTS) return
         checkCanceled()
         firFile.transform<FirElement, Any?>(FirImportResolveTransformer(firFile.moduleData.session), null)
-        firFile.replaceResolvePhase(FirResolvePhase.IMPORTS)
+        @OptIn(ResolveStateAccess::class)
+        firFile.resolveState = FirResolvePhase.IMPORTS.asResolveState()
     }
 
     /**
@@ -87,7 +88,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
      * @param target target non-local declaration
      */
     fun lazyResolve(
-        target: FirElementWithResolvePhase,
+        target: FirElementWithResolveState,
         scopeSession: ScopeSession,
         toPhase: FirResolvePhase,
     ) {
@@ -100,7 +101,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
     }
 
     private fun doLazyResolve(
-        target: FirElementWithResolvePhase,
+        target: FirElementWithResolveState,
         scopeSession: ScopeSession,
         toPhase: FirResolvePhase,
     ) {
@@ -121,7 +122,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         }
     }
 
-    private fun declarationDesignationsToResolve(target: FirElementWithResolvePhase): List<FirDesignationWithFile> {
+    private fun declarationDesignationsToResolve(target: FirElementWithResolveState): List<FirDesignationWithFile> {
         return when (target) {
             is FirPropertyAccessor -> declarationDesignationsToResolve(target.propertySymbol.fir)
             is FirBackingField -> declarationDesignationsToResolve(target.propertySymbol.fir)
@@ -203,7 +204,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
 
 private fun handleExceptionFromResolve(
     exception: Exception,
-    firDeclarationToResolve: FirElementWithResolvePhase,
+    firDeclarationToResolve: FirElementWithResolveState,
     fromPhase: FirResolvePhase,
     toPhase: FirResolvePhase?
 ): Nothing {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt

@@ -1,12 +1,12 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure
 
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.moduleData
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 
-val FirElementWithResolvePhase.llFirModuleData: LLFirModuleData
+val FirElementWithResolveState.llFirModuleData: LLFirModuleData
     get() {
         return moduleData as LLFirModuleData
     }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -9,7 +9,7 @@ import com.intellij.openapi.util.ModificationTracker
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.fir.BuiltinTypes
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
@@ -25,7 +25,7 @@ abstract class LLFirResolvableModuleSession(
     }
 }
 
-internal val FirElementWithResolvePhase.llFirResolvableSession: LLFirResolvableModuleSession?
+internal val FirElementWithResolveState.llFirResolvableSession: LLFirResolvableModuleSession?
     get() = llFirSession as? LLFirResolvableModuleSession
 
 internal val FirBasedSymbol<*>.llFirResolvableSession: LLFirResolvableModuleSession?

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
 import org.jetbrains.kotlin.analysis.providers.KtModuleStateTracker
 import org.jetbrains.kotlin.analysis.utils.trackers.CompositeModificationTracker
 import org.jetbrains.kotlin.fir.BuiltinTypes
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -102,7 +102,7 @@ abstract class LLFirModuleSession(
     kind: Kind
 ) : LLFirSession(ktModule, dependencyTracker, builtinTypes, kind)
 
-val FirElementWithResolvePhase.llFirSession: LLFirSession
+val FirElementWithResolveState.llFirSession: LLFirSession
     get() = moduleData.session as LLFirSession
 
 val FirBasedSymbol<*>.llFirSession: LLFirSession

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
@@ -43,7 +43,7 @@ internal class LLFirDeclarationTransformer(private val designation: FirDesignati
     private inline fun processDeclarationContent(
         declaration: FirDeclaration,
         default: () -> FirDeclaration,
-        applyToDesignated: (FirElementWithResolvePhase) -> Unit,
+        applyToDesignated: (FirElementWithResolveState) -> Unit,
     ): FirDeclaration {
         //It means that we are inside the target declaration
         if (isInsideTargetDeclaration) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTra
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsMappingTransformer
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 /**
  * Transform designation into ANNOTATIONS_ARGUMENTS_MAPPING declaration. Affects only for target declaration, it's children and dependents
@@ -50,7 +51,7 @@ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer(
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING)
         if (target !is FirAnnotationContainer) return
         for (annotation in target.annotations) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -12,7 +12,7 @@ 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
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -26,7 +26,7 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
     scopeSession: ScopeSession,
 ) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
 
-    private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolvePhase>) {
+    private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolveState>) {
         if (!designationIterator.hasNext()) {
             FirLazyBodiesCalculator.calculateAnnotations(designation.target)
             designation.target.transform<FirDeclaration, ResolutionMode>(declarationsTransformer, ResolutionMode.ContextIndependent)
@@ -63,13 +63,13 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
             moveNextDeclaration(designationIterator)
         }
-        
+
 
         LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         if (target !is FirAnnotationContainer) return
         val unresolvedAnnotation = target.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef }
         check(unresolvedAnnotation == null) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -20,9 +20,10 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
     private val designation: FirDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
-) : LLFirLazyTransformer, FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession, CompilerRequiredAnnotationsComputationSession()) {
+) : LLFirLazyTransformer,
+    FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession, CompilerRequiredAnnotationsComputationSession()) {
 
-    private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolvePhase>) {
+    private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolveState>) {
         if (!designationIterator.hasNext()) {
             val declaration = designation.target
             FirLazyBodiesCalculator.calculateCompilerAnnotations(declaration)
@@ -59,7 +60,7 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
         // todo add proper check that COMPILER_REQUIRED_ANNOTATIONS are resolved
 //        checkNestedDeclarationsAreResolved(declaration)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 
 /**
  * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children
@@ -54,14 +54,14 @@ internal class LLFirDesignatedBodyResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) {
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
-    
+
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.target, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true)
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.BODY_RESOLVE)
         checkNestedDeclarationsAreResolved(target)
     }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirAbstractContractResolveTransformerDispatcher
 
 /**
@@ -51,16 +51,16 @@ internal class LLFirDesignatedContractsResolveTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) {
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
-        
+
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.target, FirResolvePhase.CONTRACTS)
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.CONTRACTS)
         if (target is FirContractDescriptionOwner) {
-           // TODO checkContractDescriptionIsResolved(declaration)
+            // TODO checkContractDescriptionIsResolved(declaration)
         }
         checkNestedDeclarationsAreResolved(target)
     }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -45,14 +45,14 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
             designation.firFile.transform<FirFile, Nothing?>(this, null)
         }
-    
+
 
         declarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.target, FirResolvePhase.EXPECT_ACTUAL_MATCHING)
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
         // TODO check if expect-actual matching is present
         checkNestedDeclarationsAreResolved(target)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -7,11 +7,12 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
     val designation: FirDesignationWithFile,
@@ -30,7 +31,7 @@ internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         check(target.resolvePhase >= FirResolvePhase.COMPANION_GENERATION)
     }
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesi
 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
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 
 /**
  * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents
@@ -57,14 +57,14 @@ internal class LLFirDesignatedImplicitTypesTransformer(
         phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
             designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
         }
-    
+
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.target, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
         if (target is FirCallableDeclaration) {
             checkReturnTypeRefIsResolved(target)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 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
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -90,7 +90,7 @@ internal class LLFirDesignatedStatusResolveTransformer(
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         if (target !is FirAnonymousInitializer) {
             target.checkPhase(FirResolvePhase.STATUS)
         }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -17,7 +17,7 @@ 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.withInvalidationOnException
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass
@@ -72,7 +72,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
     }
 
     private inner class DesignationCollector {
-        private val visited = mutableMapOf<FirElementWithResolvePhase, FirDesignationWithFile>()
+        private val visited = mutableMapOf<FirElementWithResolveState, FirDesignationWithFile>()
         private val toVisit = mutableListOf<FirDesignationWithFile>()
 
         fun collect(designation: FirDesignationWithFile): Collection<FirDesignationWithFile> {
@@ -178,7 +178,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
         checkIsResolved(designation.target)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.SUPER_TYPES)
         when (target) {
             is FirClass -> {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodie
 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
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -61,7 +61,7 @@ internal class LLFirDesignatedTypeResolverTransformer(
         return super.transformTypeRef(typeRef, data)
     }
 
-    override fun checkIsResolved(target: FirElementWithResolvePhase) {
+    override fun checkIsResolved(target: FirElementWithResolveState) {
         target.checkPhase(FirResolvePhase.TYPES)
         when (target) {
             is FirCallableDeclaration -> {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 internal interface LLFirLazyTransformer {
     fun transformDeclaration(phaseRunner: LLFirPhaseRunner)
 
-    fun checkIsResolved(target: FirElementWithResolvePhase)
+    fun checkIsResolved(target: FirElementWithResolveState)
 
-    fun checkNestedDeclarationsAreResolved(target: FirElementWithResolvePhase) {
+    fun checkNestedDeclarationsAreResolved(target: FirElementWithResolveState) {
         if (target !is FirDeclaration) return
         checkFunctionParametersAreResolved(target)
         checkPropertyAccessorsAreResolved(target)
@@ -63,17 +63,22 @@ internal interface LLFirLazyTransformer {
     companion object {
         private object WholeTreePhaseUpdater : FirVisitor<Unit, FirResolvePhase>() {
             override fun visitElement(element: FirElement, data: FirResolvePhase) {
-                if (element is FirElementWithResolvePhase) {
+                if (element is FirElementWithResolveState) {
                     if (element.resolvePhase >= data && element !is FirDefaultPropertyAccessor) return
-                    element.replaceResolvePhase(data)
+
+                    @OptIn(ResolveStateAccess::class)
+                    element.resolveState = data.asResolveState()
                 }
+
                 element.acceptChildren(this, data)
             }
         }
 
-        private fun updatePhaseForNonLocals(element: FirElementWithResolvePhase, newPhase: FirResolvePhase) {
+        private fun updatePhaseForNonLocals(element: FirElementWithResolveState, newPhase: FirResolvePhase) {
             if (element.resolvePhase >= newPhase) return
-            element.replaceResolvePhase(newPhase)
+
+            @OptIn(ResolveStateAccess::class)
+            element.resolveState = newPhase.asResolveState()
 
             if (element is FirTypeParameterRefsOwner) {
                 element.typeParameters.forEach { typeParameter ->
@@ -101,7 +106,7 @@ internal interface LLFirLazyTransformer {
             }
         }
 
-        fun updatePhaseDeep(element: FirElementWithResolvePhase, newPhase: FirResolvePhase, withNonLocalDeclarations: Boolean = false) {
+        fun updatePhaseDeep(element: FirElementWithResolveState, newPhase: FirResolvePhase, withNonLocalDeclarations: Boolean = false) {
             if (withNonLocalDeclarations) {
                 WholeTreePhaseUpdater.visitElement(element, newPhase)
             } else {
@@ -114,7 +119,7 @@ internal interface LLFirLazyTransformer {
 
         val DUMMY = object : LLFirLazyTransformer {
             override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit
-            override fun checkIsResolved(target: FirElementWithResolvePhase) = error("Not implemented")
+            override fun checkIsResolved(target: FirElementWithResolveState) = error("Not implemented")
         }
     }
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -79,23 +79,24 @@ object FirElementFinder {
                 }
             }
 
+            @OptIn(ResolveStateAccess::class)
             override fun visitRegularClass(regularClass: FirRegularClass) {
                 // Checking the rest super types that weren't resolved on the first OUTER_CLASS_ARGUMENTS_REQUIRED check in FirTypeResolver
-                val oldResolvePhase = regularClass.resolvePhase
+                val oldResolveState = regularClass.resolveState
                 val oldList = regularClass.superTypeRefs.toList()
 
                 try {
                     super.visitRegularClass(regularClass)
                 } catch (e: ConcurrentModificationException) {
-                    val newResolvePhase = regularClass.resolvePhase
+                    val newResolveState = regularClass.resolveState
                     val newList = regularClass.superTypeRefs.toList()
 
                     throw IllegalStateException(
                         """
                         CME while traversing superTypeRefs of declaration=${regularClass.render()}:
                         classId: ${regularClass.classId},
-                        oldPhase: $oldResolvePhase, oldList: ${oldList.joinToString(",", "[", "]") { it.render() }},
-                        newPhase: $newResolvePhase, newList: ${newList.joinToString(",", "[", "]") { it.render() }}
+                        oldState: $oldResolveState, oldList: ${oldList.joinToString(",", "[", "]") { it.render() }},
+                        newState: $newResolveState, newList: ${newList.joinToString(",", "[", "]") { it.render() }}
                         """.trimIndent(), e
                     )
                 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 internal object LLFirResolvePhaseChecker {
     fun requireResolvePhase(firDeclaration: FirDeclaration, requiredPhase: FirResolvePhase) {

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

@@ -1,19 +1,19 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.psi.KtFile
 
-fun FirElementWithResolvePhase.getContainingFile(): FirFile? {
+fun FirElementWithResolveState.getContainingFile(): FirFile? {
     val provider = moduleData.session.firProvider
     return when (this) {
         is FirFile -> this

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
 import org.jetbrains.kotlin.analysis.utils.errors.withKtModuleEntry
 import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderer.ConeTypeRendererForDebugging
 import org.jetbrains.kotlin.fir.renderer.FirDeclarationRendererWithAttributes
@@ -33,7 +33,7 @@ fun ExceptionAttachmentBuilder.withFirEntry(name: String, fir: FirElement) {
         ).renderElementAsString(it)
     }
     withEntry("${name}FirSourceElementKind", fir.source?.kind?.let { it::class.simpleName })
-    if (fir is FirElementWithResolvePhase) {
+    if (fir is FirElementWithResolveState) {
         withKtModuleEntry("${name}KtModule", fir.llFirModuleData.ktModule)
     }
     withPsiEntry("${name}Psi", fir.psi)

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 import org.jetbrains.kotlin.analysis.utils.errors.ExceptionAttachmentBuilder
 import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
 import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
 import org.jetbrains.kotlin.fir.declarations.*
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 internal inline fun checkTypeRefIsResolved(
     typeRef: FirTypeRef,
     typeRefName: String,
-    owner: FirElementWithResolvePhase,
+    owner: FirElementWithResolveState,
     acceptImplicitTypeRef: Boolean = false,
     extraAttachment: ExceptionAttachmentBuilder.() -> Unit = {}
 ) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -7,17 +7,20 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
 import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder
-import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
+import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
-internal fun FirElementWithResolvePhase.checkPhase(requiredResolvePhase: FirResolvePhase) {
-    val declarationResolvePhase = resolvePhase
+internal fun FirElementWithResolveState.checkPhase(requiredResolvePhase: FirResolvePhase) {
+    @OptIn(ResolveStateAccess::class)
+    val declarationResolveState = resolveState
     checkWithAttachmentBuilder(
-        declarationResolvePhase >= requiredResolvePhase,
-        { "At least $requiredResolvePhase expected but $declarationResolvePhase found for ${this::class.simpleName}" }
+        declarationResolveState.resolvePhase >= requiredResolvePhase,
+        { "At least $requiredResolvePhase expected but $declarationResolveState found for ${this::class.simpleName}" },
     ) {
         withFirEntry("firDeclaration", this@checkPhase)
     }
@@ -34,8 +37,10 @@ internal fun FirDesignation.checkDesignationPhase(firResolvePhase: FirResolvePha
 internal fun FirDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) {
     checkPathPhase(firResolvePhase)
     if (target is FirClassLikeDeclaration) {
-        check(target.resolvePhase >= firResolvePhase) {
-            "Expected $firResolvePhase but found ${target.resolvePhase}"
+        @OptIn(ResolveStateAccess::class)
+        val resolveState = target.resolveState
+        check(resolveState.resolvePhase >= firResolvePhase) {
+            "Expected $firResolvePhase but found $resolveState"
         }
     }
 }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/annonymousClass.fir.txt

@@ -1,12 +1,12 @@
-FILE: [IMPORTS] annonymousClass.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun x(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval x: R|<anonymous>| = object : R|kotlin/Any| {
-            private [BODY_RESOLVE] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] annonymousClass.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval x: R|<anonymous>| = object : R|kotlin/Any| {
+            private [ResolvedTo(BODY_RESOLVE)] constructor(): R|<anonymous>| {
                 super<R|kotlin/Any|>()
             }
 
-            public final [BODY_RESOLVE] fun foo(): R|kotlin/Unit| {
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
             }
 
         }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/class.fir.txt

@@ -1,18 +1,18 @@
-FILE: [IMPORTS] class.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class B : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|B| {
+FILE: [ResolvedTo(IMPORTS)] class.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|B| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun q(): <ERROR TYPE REF: Symbol not found for C> {
+        public final [ResolvedTo(BODY_RESOLVE)] fun q(): <ERROR TYPE REF: Symbol not found for C> {
         }
 
-        private final [BODY_RESOLVE] val y: <ERROR TYPE REF: Symbol not found for C> = this@R|/B|.R|/B.q|()
-            private [BODY_RESOLVE] get(): <ERROR TYPE REF: Symbol not found for C>
+        private final [ResolvedTo(BODY_RESOLVE)] val y: <ERROR TYPE REF: Symbol not found for C> = this@R|/B|.R|/B.q|()
+            private [ResolvedTo(BODY_RESOLVE)] get(): <ERROR TYPE REF: Symbol not found for C>
 
-        public final [BODY_RESOLVE] fun foo([BODY_RESOLVE] a: <ERROR TYPE REF: Symbol not found for A>): <ERROR TYPE REF: Cannot infer argument for type parameter R> {
-            ^foo R|kotlin/with<Inapplicable(INAPPLICABLE): kotlin/with>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(R|<local>/a|, <L> = [BODY_RESOLVE] with@fun <ERROR TYPE REF: Cannot infer argument for type parameter T>.<anonymous>(): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=Unknown, kind=EXACTLY_ONCE>  {
+        public final [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] a: <ERROR TYPE REF: Symbol not found for A>): <ERROR TYPE REF: Cannot infer argument for type parameter R> {
+            ^foo R|kotlin/with<Inapplicable(INAPPLICABLE): kotlin/with>#|<<ERROR TYPE REF: Cannot infer argument for type parameter T>, <ERROR TYPE REF: Cannot infer argument for type parameter R>>(R|<local>/a|, <L> = [ResolvedTo(BODY_RESOLVE)] with@fun <ERROR TYPE REF: Cannot infer argument for type parameter T>.<anonymous>(): <ERROR TYPE REF: Cannot infer argument for type parameter R> <inline=Unknown, kind=EXACTLY_ONCE>  {
                 ^ <Unresolved name: bar>#(String(a), this@R|/B|.R|/B.y|)
             }
             )

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/class.out_of_src_roots.fir.txt

@@ -1,18 +1,18 @@
-FILE: [IMPORTS] class.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class B : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|B| {
+FILE: [ResolvedTo(IMPORTS)] class.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|B| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun q(): <ERROR TYPE REF: Symbol not found for C> {
+        public final [ResolvedTo(BODY_RESOLVE)] fun q(): <ERROR TYPE REF: Symbol not found for C> {
         }
 
-        private final [BODY_RESOLVE] val y: <ERROR TYPE REF: Symbol not found for C> = this@R|/B|.R|/B.q|()
-            private [BODY_RESOLVE] get(): <ERROR TYPE REF: Symbol not found for C>
+        private final [ResolvedTo(BODY_RESOLVE)] val y: <ERROR TYPE REF: Symbol not found for C> = this@R|/B|.R|/B.q|()
+            private [ResolvedTo(BODY_RESOLVE)] get(): <ERROR TYPE REF: Symbol not found for C>
 
-        public final [BODY_RESOLVE] fun foo([BODY_RESOLVE] a: <ERROR TYPE REF: Symbol not found for A>): <ERROR TYPE REF: Unresolved name: with> {
-            ^foo <Unresolved name: with>#(R|<local>/a|, <L> = [BODY_RESOLVE] with@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: bar> <inline=Unknown>  {
+        public final [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] a: <ERROR TYPE REF: Symbol not found for A>): <ERROR TYPE REF: Unresolved name: with> {
+            ^foo <Unresolved name: with>#(R|<local>/a|, <L> = [ResolvedTo(BODY_RESOLVE)] with@fun <anonymous>(): <ERROR TYPE REF: Unresolved name: bar> <inline=Unknown>  {
                 ^ <Unresolved name: bar>#(String(a), this@R|/B|.R|/B.y|)
             }
             )

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/constructorParameter.fir.txt

@@ -1,11 +1,11 @@
-FILE: [IMPORTS] constructorParameter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor([BODY_RESOLVE] x: R|kotlin/String|): R|A| {
+FILE: [ResolvedTo(IMPORTS)] constructorParameter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor([ResolvedTo(BODY_RESOLVE)] x: R|kotlin/String|): R|A| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] val x: R|kotlin/String| = R|<local>/x|
-            public [BODY_RESOLVE] get(): R|kotlin/String|
+        public final [ResolvedTo(BODY_RESOLVE)] val x: R|kotlin/String| = R|<local>/x|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/String|
 
     }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/enum.fir.txt

@@ -1,27 +1,27 @@
-FILE: [IMPORTS] enum.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] enum class Enum : R|kotlin/Enum<Enum>| {
-        private [BODY_RESOLVE] constructor([BODY_RESOLVE] x: R|kotlin/Int|): R|Enum| {
+FILE: [ResolvedTo(IMPORTS)] enum.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] enum class Enum : R|kotlin/Enum<Enum>| {
+        private [ResolvedTo(BODY_RESOLVE)] constructor([ResolvedTo(BODY_RESOLVE)] x: R|kotlin/Int|): R|Enum| {
             super<R|kotlin/Enum<Enum>|>()
         }
 
-        public final [BODY_RESOLVE] val x: R|kotlin/Int| = R|<local>/x|
-            public [BODY_RESOLVE] get(): R|kotlin/Int|
+        public final [ResolvedTo(BODY_RESOLVE)] val x: R|kotlin/Int| = R|<local>/x|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
 
-        public final static [BODY_RESOLVE] enum entry A: R|Enum| = object : R|Enum| {
-            private [BODY_RESOLVE] constructor(): R|<anonymous>| {
+        public final static [ResolvedTo(BODY_RESOLVE)] enum entry A: R|Enum| = object : R|Enum| {
+            private [ResolvedTo(BODY_RESOLVE)] constructor(): R|<anonymous>| {
                 super<R|Enum|>(Int(1))
             }
 
         }
 
-        public final static [BODY_RESOLVE] fun values(): R|kotlin/Array<Enum>| {
+        public final static [ResolvedTo(BODY_RESOLVE)] fun values(): R|kotlin/Array<Enum>| {
         }
 
-        public final static [BODY_RESOLVE] fun valueOf([BODY_RESOLVE] value: R|kotlin/String|): R|Enum| {
+        public final static [ResolvedTo(BODY_RESOLVE)] fun valueOf([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|Enum| {
         }
 
-        public final static [BODY_RESOLVE] val entries: R|kotlin/enums/EnumEntries<Enum>|
-            public [BODY_RESOLVE] get(): R|kotlin/enums/EnumEntries<Enum>|
+        public final static [ResolvedTo(BODY_RESOLVE)] val entries: R|kotlin/enums/EnumEntries<Enum>|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/enums/EnumEntries<Enum>|
 
     }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/funWithoutTypes.fir.txt

@@ -1,4 +1,4 @@
-FILE: [IMPORTS] funWithoutTypes.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun main(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] funWithoutTypes.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun main(): R|kotlin/Unit| {
     }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/functionValueParameter.fir.txt

@@ -1,13 +1,13 @@
-FILE: [IMPORTS] functionValueParameter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun bar([BODY_RESOLVE] a: R|kotlin/Int|, [BODY_RESOLVE] b: R|(kotlin/Boolean) -> kotlin/Unit|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionValueParameter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun bar([ResolvedTo(BODY_RESOLVE)] a: R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] b: R|(kotlin/Boolean) -> kotlin/Unit|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|A| {
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun foo([BODY_RESOLVE] x: R|kotlin/String|, [BODY_RESOLVE] y: R|() -> kotlin/String|): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] x: R|kotlin/String|, [ResolvedTo(BODY_RESOLVE)] y: R|() -> kotlin/String|): R|kotlin/Unit| {
         }
 
     }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/functionWithImplicitType.fir.txt

@@ -1,7 +1,7 @@
-FILE: [IMPORTS] functionWithImplicitType.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] T> checkSubtype([BODY_RESOLVE] t: R|T|): R|T| {
+FILE: [ResolvedTo(IMPORTS)] functionWithImplicitType.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T> checkSubtype([ResolvedTo(BODY_RESOLVE)] t: R|T|): R|T| {
         ^checkSubtype R|<local>/t|
     }
-    public final [BODY_RESOLVE] val ab: R|kotlin/collections/List<kotlin/Int>?| = R|/checkSubtype|<R|kotlin/collections/List<kotlin/Int>?|>(Q|java/util/Collections|.R|java/util/Collections.emptyList|<R|kotlin/Int|>())
-        public [BODY_RESOLVE] get(): R|kotlin/collections/List<kotlin/Int>?|
+    public final [ResolvedTo(BODY_RESOLVE)] val ab: R|kotlin/collections/List<kotlin/Int>?| = R|/checkSubtype|<R|kotlin/collections/List<kotlin/Int>?|>(Q|java/util/Collections|.R|java/util/Collections.emptyList|<R|kotlin/Int|>())
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/collections/List<kotlin/Int>?|

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/functionWithImplicitType.out_of_src_roots.fir.txt

@@ -1,7 +1,7 @@
-FILE: [IMPORTS] functionWithImplicitType.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] T> checkSubtype([BODY_RESOLVE] t: R|T|): R|T| {
+FILE: [ResolvedTo(IMPORTS)] functionWithImplicitType.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T> checkSubtype([ResolvedTo(BODY_RESOLVE)] t: R|T|): R|T| {
         ^checkSubtype R|<local>/t|
     }
-    public final [BODY_RESOLVE] val ab: R|kotlin/collections/List<kotlin/Int>?| = R|/checkSubtype<Inapplicable(INAPPLICABLE): /checkSubtype>#|<R|kotlin/collections/List<kotlin/Int>?|>(<Unresolved name: Collections>#.<Unresolved name: emptyList>#<R|kotlin/Int|>())
-        public [BODY_RESOLVE] get(): R|kotlin/collections/List<kotlin/Int>?|
+    public final [ResolvedTo(BODY_RESOLVE)] val ab: R|kotlin/collections/List<kotlin/Int>?| = R|/checkSubtype<Inapplicable(INAPPLICABLE): /checkSubtype>#|<R|kotlin/collections/List<kotlin/Int>?|>(<Unresolved name: Collections>#.<Unresolved name: emptyList>#<R|kotlin/Int|>())
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/collections/List<kotlin/Int>?|

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/lambdaInImplicitFunBody.fir.txt

@@ -1,19 +1,19 @@
-FILE: [IMPORTS] lambdaInImplicitFunBody.kt
-    [BODY_RESOLVE] annotations container
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> with([BODY_RESOLVE] receiver: R|T|, [BODY_RESOLVE] block: R|T.() -> R|): R|R| {
+FILE: [ResolvedTo(IMPORTS)] lambdaInImplicitFunBody.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> with([ResolvedTo(BODY_RESOLVE)] receiver: R|T|, [ResolvedTo(BODY_RESOLVE)] block: R|T.() -> R|): R|R| {
         ^with R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(R|<local>/receiver|)
     }
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> R|T|.let([BODY_RESOLVE] block: R|(T) -> R|): R|R| {
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> R|T|.let([ResolvedTo(BODY_RESOLVE)] block: R|(T) -> R|): R|R| {
         ^let R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(this@R|/let|)
     }
-    public final [BODY_RESOLVE] class B : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|B| {
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|B| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun foo([BODY_RESOLVE] a: R|kotlin/Int|): R|kotlin/String| {
-            ^foo R|/with|<R|kotlin/Int|, R|kotlin/String|>(R|<local>/a|, <L> = [BODY_RESOLVE] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
-                ^ this@R|special/anonymous|.R|kotlin/Int.toString|().R|/let|<R|kotlin/String|, R|kotlin/String|>(<L> = [BODY_RESOLVE] let@fun <anonymous>([BODY_RESOLVE] it: R|kotlin/String|): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
+        public final [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] a: R|kotlin/Int|): R|kotlin/String| {
+            ^foo R|/with|<R|kotlin/Int|, R|kotlin/String|>(R|<local>/a|, <L> = [ResolvedTo(BODY_RESOLVE)] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
+                ^ this@R|special/anonymous|.R|kotlin/Int.toString|().R|/let|<R|kotlin/String|, R|kotlin/String|>(<L> = [ResolvedTo(BODY_RESOLVE)] let@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] it: R|kotlin/String|): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
                     ^ R|<local>/it|
                 }
                 )

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/lambdaInImplicitPropertyBody.fir.txt

@@ -1,26 +1,26 @@
-FILE: [IMPORTS] lambdaInImplicitPropertyBody.kt
-    [BODY_RESOLVE] annotations container
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> with([BODY_RESOLVE] receiver: R|T|, [BODY_RESOLVE] block: R|T.() -> R|): R|R| {
+FILE: [ResolvedTo(IMPORTS)] lambdaInImplicitPropertyBody.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> with([ResolvedTo(BODY_RESOLVE)] receiver: R|T|, [ResolvedTo(BODY_RESOLVE)] block: R|T.() -> R|): R|R| {
         ^with R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(R|<local>/receiver|)
     }
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> R|T|.let([BODY_RESOLVE] block: R|(T) -> R|): R|R| {
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> R|T|.let([ResolvedTo(BODY_RESOLVE)] block: R|(T) -> R|): R|R| {
         ^let R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(this@R|/let|)
     }
-    public final [BODY_RESOLVE] class B : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|B| {
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|B| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] val a: R|kotlin/Int| = Int(10)
-            public [BODY_RESOLVE] get(): R|kotlin/Int|
+        public final [ResolvedTo(BODY_RESOLVE)] val a: R|kotlin/Int| = Int(10)
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
 
-        public final [BODY_RESOLVE] val x: R|kotlin/String| = R|/with|<R|kotlin/Int|, R|kotlin/String|>(this@R|/B|.R|/B.a|, <L> = [BODY_RESOLVE] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
-            ^ this@R|special/anonymous|.R|kotlin/Int.toString|().R|/let|<R|kotlin/String|, R|kotlin/String|>(<L> = [BODY_RESOLVE] let@fun <anonymous>([BODY_RESOLVE] it: R|kotlin/String|): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
+        public final [ResolvedTo(BODY_RESOLVE)] val x: R|kotlin/String| = R|/with|<R|kotlin/Int|, R|kotlin/String|>(this@R|/B|.R|/B.a|, <L> = [ResolvedTo(BODY_RESOLVE)] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
+            ^ this@R|special/anonymous|.R|kotlin/Int.toString|().R|/let|<R|kotlin/String|, R|kotlin/String|>(<L> = [ResolvedTo(BODY_RESOLVE)] let@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] it: R|kotlin/String|): R|kotlin/String| <inline=Inline, kind=UNKNOWN>  {
                 ^ R|<local>/it|
             }
             )
         }
         )
-            public [BODY_RESOLVE] get(): R|kotlin/String|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/String|
 
     }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/lambdasInWithBodyFunction.fir.txt

@@ -1,24 +1,24 @@
-FILE: [IMPORTS] lambdasInWithBodyFunction.kt
-    [BODY_RESOLVE] annotations container
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> with([BODY_RESOLVE] receiver: R|T|, [BODY_RESOLVE] block: R|T.() -> R|): R|R| {
+FILE: [ResolvedTo(IMPORTS)] lambdasInWithBodyFunction.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> with([ResolvedTo(BODY_RESOLVE)] receiver: R|T|, [ResolvedTo(BODY_RESOLVE)] block: R|T.() -> R|): R|R| {
         ^with R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(R|<local>/receiver|)
     }
-    public final inline [BODY_RESOLVE] fun <[BODY_RESOLVE] T, [BODY_RESOLVE] R> R|T|.let([BODY_RESOLVE] block: R|(T) -> R|): R|R| {
+    public final inline [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T, [ResolvedTo(BODY_RESOLVE)] R> R|T|.let([ResolvedTo(BODY_RESOLVE)] block: R|(T) -> R|): R|R| {
         ^let R|<local>/block|.R|SubstitutionOverride<kotlin/Function1.invoke: R|R|>|(this@R|/let|)
     }
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|A| {
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun foo(): R|kotlin/Unit| {
-            [BODY_RESOLVE] lval a: R|kotlin/Int| = R|/with|<R|kotlin/Int|, R|kotlin/Int|>(Int(1), <L> = [BODY_RESOLVE] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
-                ^ this@R|special/anonymous|.R|/let|<R|kotlin/Int|, R|kotlin/Int|>(<L> = [BODY_RESOLVE] let@fun <anonymous>([BODY_RESOLVE] it: R|kotlin/Int|): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
+        public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
+            [ResolvedTo(BODY_RESOLVE)] lval a: R|kotlin/Int| = R|/with|<R|kotlin/Int|, R|kotlin/Int|>(Int(1), <L> = [ResolvedTo(BODY_RESOLVE)] with@fun R|kotlin/Int|.<anonymous>(): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
+                ^ this@R|special/anonymous|.R|/let|<R|kotlin/Int|, R|kotlin/Int|>(<L> = [ResolvedTo(BODY_RESOLVE)] let@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] it: R|kotlin/Int|): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
                     ^ R|<local>/it|
                 }
                 )
             }
-            ).R|/let|<R|kotlin/Int|, R|kotlin/Int|>(<L> = [BODY_RESOLVE] let@fun <anonymous>([BODY_RESOLVE] it: R|kotlin/Int|): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
+            ).R|/let|<R|kotlin/Int|, R|kotlin/Int|>(<L> = [ResolvedTo(BODY_RESOLVE)] let@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] it: R|kotlin/Int|): R|kotlin/Int| <inline=Inline, kind=UNKNOWN>  {
                 ^ Int(2)
             }
             )

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/localClass.fir.txt

@@ -1,12 +1,12 @@
-FILE: [IMPORTS] localClass.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun x(): R|kotlin/Unit| {
-        local final [BODY_RESOLVE] class Local : R|kotlin/Any| {
-            public [BODY_RESOLVE] constructor(): R|Local| {
+FILE: [ResolvedTo(IMPORTS)] localClass.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Unit| {
+        local final [ResolvedTo(BODY_RESOLVE)] class Local : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] constructor(): R|Local| {
                 super<R|kotlin/Any|>()
             }
 
-            public final [BODY_RESOLVE] fun foo(): R|kotlin/Unit| {
+            public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
             }
 
         }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/propertyWithGetterAndSetter.fir.txt

@@ -1,9 +1,9 @@
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] var withGetterAndSetter: R|kotlin/Int| = Int(42)
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] var withGetterAndSetter: R|kotlin/Int| = Int(42)
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ F|/withGetterAndSetter|
         }
-        public [BODY_RESOLVE] set([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
             F|/withGetterAndSetter| = R|<local>/value|
         }

analysis/low-level-api-fir/testdata/innerDeclarationsResolve/propertyWithSetter.fir.txt

@@ -1,26 +1,26 @@
-FILE: [IMPORTS] propertyWithSetter.kt
-    [BODY_RESOLVE] annotations container
-    public abstract [BODY_RESOLVE] class Foo : R|kotlin/Any| {
-        public [BODY_RESOLVE] constructor(): R|Foo| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithSetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] class Foo : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|Foo| {
             super<R|kotlin/Any|>()
         }
 
-        public abstract [BODY_RESOLVE] var id: R|kotlin/Int|
-            public [BODY_RESOLVE] get(): R|kotlin/Int|
-            protected [BODY_RESOLVE] set([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit|
+        public abstract [ResolvedTo(BODY_RESOLVE)] var id: R|kotlin/Int|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
+            protected [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit|
 
     }
-    public final [BODY_RESOLVE] class Bar : R|Foo| {
-        public [BODY_RESOLVE] constructor(): R|Bar| {
+    public final [ResolvedTo(BODY_RESOLVE)] class Bar : R|Foo| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|Bar| {
             super<R|Foo|>()
         }
 
-        public open override [BODY_RESOLVE] var id: R|kotlin/Int| = Int(1)
-            public [BODY_RESOLVE] get(): R|kotlin/Int|
-            public [BODY_RESOLVE] set([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit|
+        public open override [ResolvedTo(BODY_RESOLVE)] var id: R|kotlin/Int| = Int(1)
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
+            public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit|
 
     }
-    public final [BODY_RESOLVE] fun test(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval bar: R|Bar| = R|/Bar.Bar|()
+    public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval bar: R|Bar| = R|/Bar.Bar|()
         R|<local>/bar|.R|/Bar.id| = Int(1)
     }

analysis/low-level-api-fir/testdata/lazyResolve/annotationParameters.txt

@@ -1,554 +1,554 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(RAW_FIR)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [RAW_FIR] class B : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(RAW_FIR)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [RAW_FIR] class B : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(RAW_FIR)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [RAW_FIR] class B : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(RAW_FIR)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @Anno(LAZY_EXPRESSION) public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [RAW_FIR] class B : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(RAW_FIR)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @Anno(LAZY_EXPRESSION) public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [RAW_FIR] class B : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(RAW_FIR)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @Anno(LAZY_EXPRESSION) public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [RAW_FIR] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public? final? [SUPER_TYPES] class B : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=B] constructor(): R|B| {
+    public? final? [ResolvedTo(SUPER_TYPES)] class B : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @Anno(LAZY_EXPRESSION) public? final? [SUPER_TYPES] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @Anno(LAZY_EXPRESSION) public? final? [ResolvedTo(SUPER_TYPES)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public final [SUPER_TYPES] class B : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(SUPER_TYPES)] class B : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [TYPES] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(TYPES)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] enum class X : R|kotlin/Enum<X>| {
-        private [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [RAW_FIR] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public final [SUPER_TYPES] class B : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(SUPER_TYPES)] class B : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(X#.A#) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(X#.A#) public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [TYPES] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(TYPES)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] enum class X : R|kotlin/Enum<X>| {
-        private [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [STATUS] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] fun valueOf([STATUS] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public final [STATUS] class B : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(STATUS)] class B : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(Q|X|.R|/X.A|) public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(Q|X|.R|/X.A|) public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] enum class X : R|kotlin/Enum<X>| {
-        private [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [STATUS] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] fun valueOf([STATUS] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public final [STATUS] class B : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(STATUS)] class B : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(Q|X|.R|/X.A|) public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(Q|X|.R|/X.A|) public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] enum class X : R|kotlin/Enum<X>| {
-        private [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [STATUS] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] fun valueOf([STATUS] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor([RAW_FIR] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Anno.args] args: A.X): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): A.X
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val args: A.X = R|<local>/args|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): A.X
 
     }
-    public final [STATUS] class B : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(STATUS)] class B : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(Q|X|.R|/X.A|) public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(Q|X|.R|/X.A|) public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(LAZY_EXPRESSION) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] enum class X : R|kotlin/Enum<X>| {
-        private [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [STATUS] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] fun valueOf([STATUS] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor([STATUS] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
+    public final [ResolvedTo(SUPER_TYPES)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
-            public [TYPES] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
 
     }
-    public final [STATUS] class B : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(STATUS)] class B : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(args = Q|X|.R|/X.A|) public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(args = Q|X|.R|/X.A|) public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(X#.A#) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(X#.A#) public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] annotationParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] enum class X : R|kotlin/Enum<X>| {
-        private [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Enum<X>|>
         }
 
-        public final static [STATUS] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [STATUS] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] fun valueOf([STATUS] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [STATUS] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor([STATUS] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
+    public final [ResolvedTo(SUPER_TYPES)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
-            public [TYPES] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
 
     }
-    public final [STATUS] class B : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(STATUS)] class B : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        @R|Anno|(args = Q|X|.R|/X.A|) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(args = Q|X|.R|/X.A|) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(X#.A#) public final [STATUS] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
+        @R|Anno|(X#.A#) public final [ResolvedTo(STATUS)] fun foo(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] annotationParameters.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] enum class X : R|kotlin/Enum<X>| {
-        private [BODY_RESOLVE] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] annotationParameters.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] enum class X : R|kotlin/Enum<X>| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] constructor(): R|X| {
             super<R|kotlin/Enum<X>|>()
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=X] enum entry A: R|X|
-        public final static [BODY_RESOLVE] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] enum entry A: R|X|
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] fun values(): R|kotlin/Array<X>| {
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=X] fun valueOf([BODY_RESOLVE] value: R|kotlin/String|): R|X| {
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] fun valueOf([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|X| {
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
-            public [BODY_RESOLVE] get(): R|kotlin/enums/EnumEntries<X>|
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] val entries: R|kotlin/enums/EnumEntries<X>|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/enums/EnumEntries<X>|
 
     }
-    public final [BODY_RESOLVE] annotation class Anno : R|kotlin/Annotation| {
-        public [BODY_RESOLVE] [ContainingClassKey=Anno] constructor([BODY_RESOLVE] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
+    public final [ResolvedTo(BODY_RESOLVE)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Anno] constructor([ResolvedTo(BODY_RESOLVE)] [CorrespondingProperty=/Anno.args] args: <ERROR TYPE REF: Symbol not found for A.X>): R|Anno| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
-            public [BODY_RESOLVE] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
+        public final [ResolvedTo(BODY_RESOLVE)] [IsFromPrimaryConstructor=true] val args: <ERROR TYPE REF: Symbol not found for A.X> = R|<local>/args|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for A.X>
 
     }
-    public final [BODY_RESOLVE] class B : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=B] constructor(): R|B| {
+    public final [ResolvedTo(BODY_RESOLVE)] class B : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=B] constructor(): R|B| {
             super<R|kotlin/Any|>()
         }
 
-        @R|Anno|(args = Q|X|.R|/X.A|) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        @R|Anno|(args = Q|X|.R|/X.A|) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
-        @R|Anno|(args = Q|X|.R|/X.A|) public final [BODY_RESOLVE] fun foo(): R|kotlin/Unit| {
+        @R|Anno|(args = Q|X|.R|/X.A|) public final [ResolvedTo(BODY_RESOLVE)] fun foo(): R|kotlin/Unit| {
         }
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/annotationWithTypeArgument.txt

@@ -1,202 +1,202 @@
 RAW_FIR:
-FILE: [RAW_FIR] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(RAW_FIR)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @Anno<Int>(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @Anno<Int>(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @Anno<Int>(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @Anno<Int>(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @Anno<Int>(LAZY_EXPRESSION) public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @Anno<Int>(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @Anno<Int>(LAZY_EXPRESSION) public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @Anno<Int>(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @Anno<Int>(LAZY_EXPRESSION) public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @Anno<Int>(LAZY_EXPRESSION) public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(LAZY_EXPRESSION) public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @R|one/Anno<kotlin/Int>|(LAZY_EXPRESSION) public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(LAZY_EXPRESSION) public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    @R|one/Anno<kotlin/Int>|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(<getClass>(Int#)) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(<getClass>(Int#)) public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 CONTRACTS:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno<[RAW_FIR] T : Number> : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor<[RAW_FIR] T : Number>([RAW_FIR] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno<[ResolvedTo(RAW_FIR)] T : Number> : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor<[ResolvedTo(RAW_FIR)] T : Number>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=one/Anno.value] value: KClass<T>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Anno] get(): KClass<T>
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: KClass<T> = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] get(): KClass<T>
 
     }
-    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(<getClass>(Q|kotlin/Int|)) public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public final [TYPES] annotation class Anno<[TYPES] T : R|kotlin/Number|> : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor<[TYPES] T : R|kotlin/Number|>([STATUS] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(TYPES)] annotation class Anno<[ResolvedTo(TYPES)] T : R|kotlin/Number|> : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor<[ResolvedTo(TYPES)] T : R|kotlin/Number|>([ResolvedTo(STATUS)] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
-            public [TYPES] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
 
     }
-    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [RAW_FIR] annotations container
-    public final [TYPES] annotation class Anno<[TYPES] T : R|kotlin/Number|> : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor<[TYPES] T : R|kotlin/Number|>([STATUS] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(TYPES)] annotation class Anno<[ResolvedTo(TYPES)] T : R|kotlin/Number|> : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor<[ResolvedTo(TYPES)] T : R|kotlin/Number|>([ResolvedTo(STATUS)] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
-            public [TYPES] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
 
     }
-    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] annotationWithTypeArgument.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] annotation class Anno<[BODY_RESOLVE] T : R|kotlin/Number|> : R|kotlin/Annotation| {
-        public [BODY_RESOLVE] [ContainingClassKey=Anno] constructor<[BODY_RESOLVE] T : R|kotlin/Number|>([BODY_RESOLVE] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
+FILE: [ResolvedTo(IMPORTS)] annotationWithTypeArgument.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] annotation class Anno<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Number|> : R|kotlin/Annotation| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Anno] constructor<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Number|>([ResolvedTo(BODY_RESOLVE)] [CorrespondingProperty=one/Anno.value] value: <ERROR TYPE REF: Symbol not found for KClass>): R|one/Anno<T>| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
-            public [BODY_RESOLVE] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
+        public final [ResolvedTo(BODY_RESOLVE)] [IsFromPrimaryConstructor=true] val value: <ERROR TYPE REF: Symbol not found for KClass> = R|<local>/value|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Anno] get(): <ERROR TYPE REF: Symbol not found for KClass>
 
     }
-    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    @R|one/Anno<kotlin/Int>|(value = <getClass>(Q|kotlin/Int|)) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }

analysis/low-level-api-fir/testdata/lazyResolve/annotations.txt

@@ -1,91 +1,91 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] annotations.kt
+FILE: [ResolvedTo(RAW_FIR)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @Suppress(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @Suppress(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @Suppress(LAZY_EXPRESSION) public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @Suppress(LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @Suppress(LAZY_EXPRESSION) public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @Suppress(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @Suppress(LAZY_EXPRESSION) public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @Suppress(LAZY_EXPRESSION) public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @Suppress(LAZY_EXPRESSION) public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @Suppress(LAZY_EXPRESSION) public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(LAZY_EXPRESSION) public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(LAZY_EXPRESSION) public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(LAZY_EXPRESSION) public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(LAZY_EXPRESSION) public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(String(2)) public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(String(2)) public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(String(2)) public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(String(2)) public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 CONTRACTS:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(String(2)) public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(String(2)) public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(LAZY_EXPRESSION)
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(String(2)) public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(String(2)) public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(String(1))
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(names = vararg(String(2))) public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(names = vararg(String(2))) public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:Suppress(String(1))
-    [RAW_FIR] annotations container
-    @R|kotlin/Suppress|(names = vararg(String(2))) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/Suppress|(names = vararg(String(2))) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] annotations.kt
+FILE: [ResolvedTo(IMPORTS)] annotations.kt
     @FILE:R|kotlin/Suppress|(names = vararg(String(1)))
-    [BODY_RESOLVE] annotations container
-    @R|kotlin/Suppress|(names = vararg(String(2))) public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    @R|kotlin/Suppress|(names = vararg(String(2))) public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
     }

analysis/low-level-api-fir/testdata/lazyResolve/classMembers.txt

@@ -1,287 +1,287 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(RAW_FIR)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] val x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] val x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] val x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] val x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] val x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] class A : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [SUPER_TYPES] val x: Int = LAZY_EXPRESSION
-            public? [SUPER_TYPES] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] val x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=A] get(): Int { LAZY_BLOCK }
 
-        public? final? [SUPER_TYPES] fun receive([SUPER_TYPES] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] fun receive([ResolvedTo(SUPER_TYPES)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public? final? [SUPER_TYPES] fun functionWithLazyBody(): String { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [TYPES] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [TYPES] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(TYPES)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [TYPES] fun receive([TYPES] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] fun receive([ResolvedTo(TYPES)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [TYPES] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
             receive#(functionWithLazyBody#())
         }
 
-        public final [TYPES] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [TYPES] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(TYPES)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [TYPES] fun receive([TYPES] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] fun receive([ResolvedTo(TYPES)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [TYPES] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(TYPES)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
             receive#(functionWithLazyBody#())
         }
 
-        public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [STATUS] fun receive([STATUS] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun receive([ResolvedTo(STATUS)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [STATUS] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
             receive#(functionWithLazyBody#())
         }
 
-        public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [STATUS] fun receive([STATUS] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun receive([ResolvedTo(STATUS)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [STATUS] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
             receive#(functionWithLazyBody#())
         }
 
-        public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [STATUS] fun receive([STATUS] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun receive([ResolvedTo(STATUS)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [STATUS] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
             receive#(functionWithLazyBody#())
         }
 
-        public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [STATUS] fun receive([STATUS] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun receive([ResolvedTo(STATUS)] value: R|kotlin/String|): R|kotlin/Unit| { LAZY_BLOCK }
 
-        public final [STATUS] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun functionWithLazyBody(): R|kotlin/String| { LAZY_BLOCK }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] classMembers.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
             this@R|/A|.R|/A.receive|(this@R|/A|.R|/A.functionWithLazyBody|())
         }
 
-        public final [STATUS] val x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] val x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=A] get(): R|kotlin/Int| { LAZY_BLOCK }
 
-        public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/String|): R|kotlin/Unit| {
+        public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit| {
         }
 
-        public final [CONTRACTS] fun functionWithLazyBody(): R|kotlin/String| {
+        public final [ResolvedTo(CONTRACTS)] fun functionWithLazyBody(): R|kotlin/String| {
             ^functionWithLazyBody String(42)
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] classMembers.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] classMembers.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
             this@R|/A|.R|/A.receive|(this@R|/A|.R|/A.functionWithLazyBody|())
         }
 
-        public final [BODY_RESOLVE] [IsReferredViaField=true] val x: R|kotlin/Int| = Int(10)
-            public [BODY_RESOLVE] [ContainingClassKey=A] get(): R|kotlin/Int| {
+        public final [ResolvedTo(BODY_RESOLVE)] [IsReferredViaField=true] val x: R|kotlin/Int| = Int(10)
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] get(): R|kotlin/Int| {
                 ^ this@R|/A|.F|/A.x|
             }
 
-        public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/String|): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|kotlin/Unit| {
         }
 
-        public final [BODY_RESOLVE] fun functionWithLazyBody(): R|kotlin/String| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
             ^functionWithLazyBody String(42)
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/classes/classWithTypeParameters.txt

@@ -1,139 +1,139 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class ResolveMe<[RAW_FIR] T : Int, [RAW_FIR] K> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=ResolveMe] constructor<[RAW_FIR] T : Int, [RAW_FIR] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(RAW_FIR)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class ResolveMe<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class ResolveMe<[RAW_FIR] T : Int, [RAW_FIR] K> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=ResolveMe] constructor<[RAW_FIR] T : Int, [RAW_FIR] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class ResolveMe<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] class ResolveMe<[COMPILER_REQUIRED_ANNOTATIONS] T : Int, [COMPILER_REQUIRED_ANNOTATIONS] K> : R|kotlin/Any| {
-        public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=ResolveMe] constructor<[COMPILER_REQUIRED_ANNOTATIONS] T : Int, [COMPILER_REQUIRED_ANNOTATIONS] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class ResolveMe<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T : Int, [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T : Int, [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] class ResolveMe<[COMPANION_GENERATION] T : Int, [COMPANION_GENERATION] K> : R|kotlin/Any| {
-        public? [COMPANION_GENERATION] [ContainingClassKey=ResolveMe] constructor<[COMPANION_GENERATION] T : Int, [COMPANION_GENERATION] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] class ResolveMe<[ResolvedTo(COMPANION_GENERATION)] T : Int, [ResolvedTo(COMPANION_GENERATION)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(COMPANION_GENERATION)] T : Int, [ResolvedTo(COMPANION_GENERATION)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] class ResolveMe<[SUPER_TYPES] T : Int, [SUPER_TYPES] K> : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=ResolveMe] constructor<[SUPER_TYPES] T : Int, [SUPER_TYPES] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class ResolveMe<[ResolvedTo(SUPER_TYPES)] T : Int, [ResolvedTo(SUPER_TYPES)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(SUPER_TYPES)] T : Int, [ResolvedTo(SUPER_TYPES)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 TYPES:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] class ResolveMe<[TYPES] T : R|kotlin/Int|, [TYPES] K> : R|kotlin/Any| {
-        public? [TYPES] [ContainingClassKey=ResolveMe] constructor<[TYPES] T : R|kotlin/Int|, [TYPES] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] class ResolveMe<[ResolvedTo(TYPES)] T : R|kotlin/Int|, [ResolvedTo(TYPES)] K> : R|kotlin/Any| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(TYPES)] T : R|kotlin/Int|, [ResolvedTo(TYPES)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 STATUS:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class ResolveMe<[STATUS] T : R|kotlin/Int|, [STATUS] K> : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=ResolveMe] constructor<[STATUS] T : R|kotlin/Int|, [STATUS] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class ResolveMe<[ResolvedTo(STATUS)] T : R|kotlin/Int|, [ResolvedTo(STATUS)] K> : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(STATUS)] T : R|kotlin/Int|, [ResolvedTo(STATUS)] K>(): R|ResolveMe<T, K>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] class ResolveMe<[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> : R|kotlin/Any| {
-        public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=ResolveMe] constructor<[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class ResolveMe<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T : R|kotlin/Int|, [ResolvedTo(EXPECT_ACTUAL_MATCHING)] K> : R|kotlin/Any| {
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T : R|kotlin/Int|, [ResolvedTo(EXPECT_ACTUAL_MATCHING)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] class ResolveMe<[ARGUMENTS_OF_ANNOTATIONS] T : R|kotlin/Int|, [ARGUMENTS_OF_ANNOTATIONS] K> : R|kotlin/Any| {
-        public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=ResolveMe] constructor<[ARGUMENTS_OF_ANNOTATIONS] T : R|kotlin/Int|, [ARGUMENTS_OF_ANNOTATIONS] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class ResolveMe<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T : R|kotlin/Int|, [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] K> : R|kotlin/Any| {
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T : R|kotlin/Int|, [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] class ResolveMe<[CONTRACTS] T : R|kotlin/Int|, [CONTRACTS] K> : R|kotlin/Any| {
-        public [CONTRACTS] [ContainingClassKey=ResolveMe] constructor<[CONTRACTS] T : R|kotlin/Int|, [CONTRACTS] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] class ResolveMe<[ResolvedTo(CONTRACTS)] T : R|kotlin/Int|, [ResolvedTo(CONTRACTS)] K> : R|kotlin/Any| {
+        public [ResolvedTo(CONTRACTS)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(CONTRACTS)] T : R|kotlin/Int|, [ResolvedTo(CONTRACTS)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] class ResolveMe<[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> : R|kotlin/Any| {
-        public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor<[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class ResolveMe<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] K> : R|kotlin/Any| {
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] class ResolveMe<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> : R|kotlin/Any| {
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=ResolveMe] constructor<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class ResolveMe<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T : R|kotlin/Int|, [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] K> : R|kotlin/Any| {
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T : R|kotlin/Int|, [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] class ResolveMe<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class ResolveMe<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] classWithTypeParameters.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class ResolveMe<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K>(): R|ResolveMe<T, K>| {
+FILE: [ResolvedTo(IMPORTS)] classWithTypeParameters.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class ResolveMe<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K>(): R|ResolveMe<T, K>| {
             super<R|kotlin/Any|>()
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/classes/functionInValueClass.txt

@@ -1,217 +1,217 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @JvmInline() public? final? inline [RAW_FIR] class Value : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Value] constructor([RAW_FIR] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(RAW_FIR)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @JvmInline() public? final? inline [ResolvedTo(RAW_FIR)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @JvmInline() public? final? inline [RAW_FIR] class Value : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Value] constructor([RAW_FIR] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @JvmInline() public? final? inline [ResolvedTo(RAW_FIR)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @JvmInline() public? final? inline [RAW_FIR] class Value : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Value] constructor([RAW_FIR] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @JvmInline() public? final? inline [ResolvedTo(RAW_FIR)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @JvmInline() public? final? inline [RAW_FIR] class Value : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Value] constructor([RAW_FIR] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @JvmInline() public? final? inline [ResolvedTo(RAW_FIR)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @JvmInline() public? final? inline [RAW_FIR] class Value : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Value] constructor([RAW_FIR] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @JvmInline() public? final? inline [ResolvedTo(RAW_FIR)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] constructor([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [RAW_FIR] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public? final? inline [SUPER_TYPES] class Value : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=Value] constructor([SUPER_TYPES] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public? final? inline [ResolvedTo(SUPER_TYPES)] class Value : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Value] constructor([ResolvedTo(SUPER_TYPES)] [CorrespondingProperty=/Value.value] value: Int): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [SUPER_TYPES] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
-            public? [SUPER_TYPES] [ContainingClassKey=Value] get(): Int
+        public? final? [ResolvedTo(SUPER_TYPES)] [IsFromPrimaryConstructor=true] val value: Int = R|<local>/value|
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Value] get(): Int
 
-        public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [SUPER_TYPES] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=Value] constructor([TYPES] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(SUPER_TYPES)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=Value] constructor([ResolvedTo(TYPES)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [TYPES] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [SUPER_TYPES] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=Value] constructor([TYPES] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(SUPER_TYPES)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=Value] constructor([ResolvedTo(TYPES)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [TYPES] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [TYPES] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(TYPES)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(STATUS)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Value] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(STATUS)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Value] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(STATUS)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Value] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(STATUS)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Value] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] functionInValueClass.kt
-    [RAW_FIR] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [STATUS] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=Value] constructor([STATUS] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(STATUS)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Value] constructor([ResolvedTo(STATUS)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [STATUS] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] functionInValueClass.kt
-    [BODY_RESOLVE] annotations container
-    @R|kotlin/jvm/JvmInline|() public final inline [BODY_RESOLVE] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=Value] constructor([BODY_RESOLVE] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
+FILE: [ResolvedTo(IMPORTS)] functionInValueClass.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    @R|kotlin/jvm/JvmInline|() public final inline [ResolvedTo(BODY_RESOLVE)] [FirValueClassRepresentationKey=InlineClassRepresentation(underlyingPropertyName=value, underlyingType=kotlin/Int)] class Value : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Value] constructor([ResolvedTo(BODY_RESOLVE)] [CorrespondingProperty=/Value.value] value: R|kotlin/Int|): R|Value| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
-            public [BODY_RESOLVE] [ContainingClassKey=Value] get(): R|kotlin/Int|
+        public final [ResolvedTo(BODY_RESOLVE)] [IsFromPrimaryConstructor=true] val value: R|kotlin/Int| = R|<local>/value|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Value] get(): R|kotlin/Int|
 
-        public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         }
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/classes/nestedClassWithPropertiesOverrides.txt

@@ -1,349 +1,349 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface OV : R|kotlin/Any| {
-        public? final? [RAW_FIR] val originalExpressions: A
-            public? [RAW_FIR] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(RAW_FIR)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] val originalExpressions: A
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OV] get(): A
 
-        public? final? [RAW_FIR] class ResolveMe : OV {
-            public? [RAW_FIR] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(RAW_FIR)] class ResolveMe : OV {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [RAW_FIR] val originalExpressions: A
-                public? [RAW_FIR] [ContainingClassKey=ResolveMe] get(): A
+            public? open? override [ResolvedTo(RAW_FIR)] val originalExpressions: A
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] get(): A
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface OV : R|kotlin/Any| {
-        public? final? [RAW_FIR] val originalExpressions: A
-            public? [RAW_FIR] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] val originalExpressions: A
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OV] get(): A
 
-        public? final? [RAW_FIR] class ResolveMe : OV {
-            public? [RAW_FIR] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(RAW_FIR)] class ResolveMe : OV {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [RAW_FIR] val originalExpressions: A
-                public? [RAW_FIR] [ContainingClassKey=ResolveMe] get(): A
+            public? open? override [ResolvedTo(RAW_FIR)] val originalExpressions: A
+                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=ResolveMe] get(): A
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface OV : R|kotlin/Any| {
-        public? final? [RAW_FIR] val originalExpressions: A
-            public? [RAW_FIR] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] val originalExpressions: A
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OV] get(): A
 
-        public? final? [COMPILER_REQUIRED_ANNOTATIONS] class ResolveMe : OV {
-            public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class ResolveMe : OV {
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [COMPILER_REQUIRED_ANNOTATIONS] val originalExpressions: A
-                public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=ResolveMe] get(): A
+            public? open? override [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val originalExpressions: A
+                public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=ResolveMe] get(): A
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface OV : R|kotlin/Any| {
-        public? final? [RAW_FIR] val originalExpressions: A
-            public? [RAW_FIR] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] val originalExpressions: A
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OV] get(): A
 
-        public? final? [COMPANION_GENERATION] class ResolveMe : OV {
-            public? [COMPANION_GENERATION] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(COMPANION_GENERATION)] class ResolveMe : OV {
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [COMPANION_GENERATION] val originalExpressions: A
-                public? [COMPANION_GENERATION] [ContainingClassKey=ResolveMe] get(): A
+            public? open? override [ResolvedTo(COMPANION_GENERATION)] val originalExpressions: A
+                public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=ResolveMe] get(): A
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface OV : R|kotlin/Any| {
-        public? final? [RAW_FIR] val originalExpressions: A
-            public? [RAW_FIR] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] val originalExpressions: A
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OV] get(): A
 
-        public? final? [SUPER_TYPES] class ResolveMe : R|OV| {
-            public? [SUPER_TYPES] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(SUPER_TYPES)] class ResolveMe : R|OV| {
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [SUPER_TYPES] val originalExpressions: A
-                public? [SUPER_TYPES] [ContainingClassKey=ResolveMe] get(): A
+            public? open? override [ResolvedTo(SUPER_TYPES)] val originalExpressions: A
+                public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=ResolveMe] get(): A
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 TYPES:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] interface OV : R|kotlin/Any| {
-        public? final? [SUPER_TYPES] val originalExpressions: A
-            public? [SUPER_TYPES] [ContainingClassKey=OV] get(): A
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] interface OV : R|kotlin/Any| {
+        public? final? [ResolvedTo(SUPER_TYPES)] val originalExpressions: A
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=OV] get(): A
 
-        public? final? [TYPES] class ResolveMe : R|OV| {
-            public? [TYPES] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public? final? [ResolvedTo(TYPES)] class ResolveMe : R|OV| {
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public? open? override [TYPES] val originalExpressions: R|A|
-                public? [TYPES] [ContainingClassKey=ResolveMe] get(): R|A|
+            public? open? override [ResolvedTo(TYPES)] val originalExpressions: R|A|
+                public? [ResolvedTo(TYPES)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 STATUS:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [SUPER_TYPES] interface OV : R|kotlin/Any| {
-        public abstract [TYPES] val originalExpressions: R|A|
-            public [TYPES] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(SUPER_TYPES)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(TYPES)] val originalExpressions: R|A|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [STATUS] class ResolveMe : R|OV| {
-            public [STATUS] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(STATUS)] class ResolveMe : R|OV| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 LAZY_super<<implicit>>
             }
 
-            public open override [STATUS] val originalExpressions: R|A|
-                public [STATUS] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(STATUS)] val originalExpressions: R|A|
+                public [ResolvedTo(STATUS)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [SUPER_TYPES] interface OV : R|kotlin/Any| {
-        public abstract [TYPES] val originalExpressions: R|A|
-            public [TYPES] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(SUPER_TYPES)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(TYPES)] val originalExpressions: R|A|
+            public [ResolvedTo(TYPES)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [EXPECT_ACTUAL_MATCHING] class ResolveMe : R|OV| {
-            public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class ResolveMe : R|OV| {
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<<implicit>>()
             }
 
-            public open override [EXPECT_ACTUAL_MATCHING] val originalExpressions: R|A|
-                public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val originalExpressions: R|A|
+                public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [STATUS] interface OV : R|kotlin/Any| {
-        public abstract [STATUS] val originalExpressions: R|A|
-            public [STATUS] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] val originalExpressions: R|A|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [ARGUMENTS_OF_ANNOTATIONS] class ResolveMe : R|OV| {
-            public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class ResolveMe : R|OV| {
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<<implicit>>()
             }
 
-            public open override [ARGUMENTS_OF_ANNOTATIONS] val originalExpressions: R|A|
-                public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val originalExpressions: R|A|
+                public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [STATUS] interface OV : R|kotlin/Any| {
-        public abstract [STATUS] val originalExpressions: R|A|
-            public [STATUS] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] val originalExpressions: R|A|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [CONTRACTS] class ResolveMe : R|OV| {
-            public [CONTRACTS] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(CONTRACTS)] class ResolveMe : R|OV| {
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<<implicit>>()
             }
 
-            public open override [CONTRACTS] val originalExpressions: R|A|
-                public [CONTRACTS] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(CONTRACTS)] val originalExpressions: R|A|
+                public [ResolvedTo(CONTRACTS)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [STATUS] interface OV : R|kotlin/Any| {
-        public abstract [STATUS] val originalExpressions: R|A|
-            public [STATUS] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] val originalExpressions: R|A|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [IMPLICIT_TYPES_BODY_RESOLVE] class ResolveMe : R|OV| {
-            public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class ResolveMe : R|OV| {
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<<implicit>>()
             }
 
-            public open override [IMPLICIT_TYPES_BODY_RESOLVE] val originalExpressions: R|A|
-                public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val originalExpressions: R|A|
+                public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [STATUS] interface OV : R|kotlin/Any| {
-        public abstract [STATUS] val originalExpressions: R|A|
-            public [STATUS] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] val originalExpressions: R|A|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [ANNOTATIONS_ARGUMENTS_MAPPING] class ResolveMe : R|OV| {
-            public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class ResolveMe : R|OV| {
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<<implicit>>()
             }
 
-            public open override [ANNOTATIONS_ARGUMENTS_MAPPING] val originalExpressions: R|A|
-                public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val originalExpressions: R|A|
+                public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [RAW_FIR] annotations container
-    public abstract [STATUS] interface OV : R|kotlin/Any| {
-        public abstract [STATUS] val originalExpressions: R|A|
-            public [STATUS] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public abstract [ResolvedTo(STATUS)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] val originalExpressions: R|A|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [BODY_RESOLVE] class ResolveMe : R|OV| {
-            public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(BODY_RESOLVE)] class ResolveMe : R|OV| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<R|kotlin/Any|>()
             }
 
-            public open override [BODY_RESOLVE] val originalExpressions: R|A|
-                public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(BODY_RESOLVE)] val originalExpressions: R|A|
+                public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] nestedClassWithPropertiesOverrides.kt
-    [BODY_RESOLVE] annotations container
-    public abstract [BODY_RESOLVE] interface OV : R|kotlin/Any| {
-        public abstract [BODY_RESOLVE] val originalExpressions: R|A|
-            public [BODY_RESOLVE] [ContainingClassKey=OV] get(): R|A|
+FILE: [ResolvedTo(IMPORTS)] nestedClassWithPropertiesOverrides.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface OV : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] val originalExpressions: R|A|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OV] get(): R|A|
 
-        public final [BODY_RESOLVE] class ResolveMe : R|OV| {
-            public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
+        public final [ResolvedTo(BODY_RESOLVE)] class ResolveMe : R|OV| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] constructor(): R|OV.ResolveMe| {
                 super<R|kotlin/Any|>()
             }
 
-            public open override [BODY_RESOLVE] val originalExpressions: R|A|
-                public [BODY_RESOLVE] [ContainingClassKey=ResolveMe] get(): R|A|
+            public open override [ResolvedTo(BODY_RESOLVE)] val originalExpressions: R|A|
+                public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=ResolveMe] get(): R|A|
 
         }
 
     }
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=A] constructor(): R|A| {
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt

@@ -1,483 +1,483 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(RAW_FIR)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 IMPORTS:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 SUPER_TYPES:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 TYPES:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 STATUS:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(valueWithExplicitType#)
         receive#(valueWithImplicitType#)
         variableWithExplicitType# = IntegerLiteral(10)
         variableWithImplicitType# = IntegerLiteral(10)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(valueWithExplicitType#)
         receive#(valueWithImplicitType#)
         variableWithExplicitType# = IntegerLiteral(10)
         variableWithImplicitType# = IntegerLiteral(10)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 CONTRACTS:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(valueWithExplicitType#)
         receive#(valueWithImplicitType#)
         variableWithExplicitType# = IntegerLiteral(10)
         variableWithImplicitType# = IntegerLiteral(10)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(valueWithExplicitType#)
         receive#(valueWithImplicitType#)
         variableWithExplicitType# = IntegerLiteral(10)
         variableWithImplicitType# = IntegerLiteral(10)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(valueWithExplicitType#)
         receive#(valueWithImplicitType#)
         variableWithExplicitType# = IntegerLiteral(10)
         variableWithImplicitType# = IntegerLiteral(10)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val delegate: <implicit> = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit>
-    public? final? [RAW_FIR] val valueWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val delegate: <implicit> = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public? final? [RAW_FIR] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] val valueWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/valueWithImplicitType|.getValue#(Null(null), ::R|/valueWithImplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithExplicitType: Intby LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithExplicitType: Intby LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public? final? [RAW_FIR] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
-        public? [RAW_FIR] get(): <implicit> {
+    public? final? [ResolvedTo(RAW_FIR)] var variableWithImplicitType: <implicit>by LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): <implicit> {
             ^ D|/variableWithImplicitType|.getValue#(Null(null), ::R|/variableWithImplicitType|)
         }
-        public? [RAW_FIR] set([RAW_FIR] <set-?>: <implicit>): R|kotlin/Unit| {
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] <set-?>: <implicit>): R|kotlin/Unit| {
             D|/variableWithImplicitType|.setValue#(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] delegates.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/valueWithExplicitType|)
         R|/receive|(R|/valueWithImplicitType|)
         R|/variableWithExplicitType| = Int(10)
         R|/variableWithImplicitType| = Int(10)
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [CONTRACTS] val delegate: R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| = object : R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+    public final [ResolvedTo(CONTRACTS)] val delegate: R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| = object : R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<R|kotlin/Any|>()
         }
 
-        public open override operator [RAW_FIR] fun getValue([RAW_FIR] thisRef: R|kotlin/Any?|, [RAW_FIR] property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
+        public open override operator [ResolvedTo(RAW_FIR)] fun getValue([ResolvedTo(RAW_FIR)] thisRef: R|kotlin/Any?|, [ResolvedTo(RAW_FIR)] property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
             ^getValue Int(1)
         }
 
-        public open override operator [RAW_FIR] fun setValue([RAW_FIR] thisRef: R|kotlin/Any?|, [RAW_FIR] property: R|kotlin/reflect/KProperty<*>|, [RAW_FIR] value: R|kotlin/Int|): R|kotlin/Unit| {
+        public open override operator [ResolvedTo(RAW_FIR)] fun setValue([ResolvedTo(RAW_FIR)] thisRef: R|kotlin/Any?|, [ResolvedTo(RAW_FIR)] property: R|kotlin/reflect/KProperty<*>|, [ResolvedTo(RAW_FIR)] value: R|kotlin/Int|): R|kotlin/Unit| {
         }
 
     }
 
-        public [CONTRACTS] get(): R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>|
-    public final [CONTRACTS] val valueWithExplicitType: R|kotlin/Int|by delegate#
-        public [CONTRACTS] get(): R|kotlin/Int| {
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>|
+    public final [ResolvedTo(CONTRACTS)] val valueWithExplicitType: R|kotlin/Int|by delegate#
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int| {
             ^ D|/valueWithExplicitType|.getValue#(Null(null), ::R|/valueWithExplicitType|)
         }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] val valueWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [IMPLICIT_TYPES_BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val valueWithImplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/valueWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/valueWithImplicitType|)
         }
-    public final [CONTRACTS] var variableWithExplicitType: R|kotlin/Int|by delegate#
-        public [CONTRACTS] get(): R|kotlin/Int| {
+    public final [ResolvedTo(CONTRACTS)] var variableWithExplicitType: R|kotlin/Int|by delegate#
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int| {
             ^ D|/variableWithExplicitType|.getValue#(Null(null), ::R|/variableWithExplicitType|)
         }
-        public [CONTRACTS] set([CONTRACTS] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(CONTRACTS)] set([ResolvedTo(CONTRACTS)] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
             D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] var variableWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [IMPLICIT_TYPES_BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] var variableWithImplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/variableWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/variableWithImplicitType|)
         }
-        public [IMPLICIT_TYPES_BODY_RESOLVE] set([IMPLICIT_TYPES_BODY_RESOLVE] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] set([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
             D|/variableWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.setValue: R|kotlin/Unit|>|(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] delegates.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] delegates.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/valueWithExplicitType|)
         R|/receive|(R|/valueWithImplicitType|)
         R|/variableWithExplicitType| = Int(10)
         R|/variableWithImplicitType| = Int(10)
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] val delegate: R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| = object : R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| {
-        private [BODY_RESOLVE] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+    public final [ResolvedTo(BODY_RESOLVE)] val delegate: R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| = object : R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<R|kotlin/Any|>()
         }
 
-        public open override operator [BODY_RESOLVE] fun getValue([BODY_RESOLVE] thisRef: R|kotlin/Any?|, [BODY_RESOLVE] property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
+        public open override operator [ResolvedTo(BODY_RESOLVE)] fun getValue([ResolvedTo(BODY_RESOLVE)] thisRef: R|kotlin/Any?|, [ResolvedTo(BODY_RESOLVE)] property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
             ^getValue Int(1)
         }
 
-        public open override operator [BODY_RESOLVE] fun setValue([BODY_RESOLVE] thisRef: R|kotlin/Any?|, [BODY_RESOLVE] property: R|kotlin/reflect/KProperty<*>|, [BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+        public open override operator [ResolvedTo(BODY_RESOLVE)] fun setValue([ResolvedTo(BODY_RESOLVE)] thisRef: R|kotlin/Any?|, [ResolvedTo(BODY_RESOLVE)] property: R|kotlin/reflect/KProperty<*>|, [ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
         }
 
     }
 
-        public [BODY_RESOLVE] get(): R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>|
-    public final [BODY_RESOLVE] val valueWithExplicitType: R|kotlin/Int|by R|/delegate|
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>|
+    public final [ResolvedTo(BODY_RESOLVE)] val valueWithExplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/valueWithExplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/valueWithExplicitType|)
         }
-    public final [BODY_RESOLVE] val valueWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] val valueWithImplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/valueWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/valueWithImplicitType|)
         }
-    public final [BODY_RESOLVE] var variableWithExplicitType: R|kotlin/Int|by R|/delegate|
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] var variableWithExplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/variableWithExplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/variableWithExplicitType|)
         }
-        public [BODY_RESOLVE] set([BODY_RESOLVE] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
             D|/variableWithExplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.setValue: R|kotlin/Unit|>|(Null(null), ::R|/variableWithExplicitType|, R|<local>/variableWithExplicitType|)
         }
-    public final [BODY_RESOLVE] var variableWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] var variableWithImplicitType: R|kotlin/Int|by R|/delegate|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ D|/variableWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.getValue: R|kotlin/Int|>|(Null(null), ::R|/variableWithImplicitType|)
         }
-        public [BODY_RESOLVE] set([BODY_RESOLVE] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] <set-?>: R|kotlin/Int|): R|kotlin/Unit| {
             D|/variableWithImplicitType|.R|SubstitutionOverride<kotlin/properties/ReadWriteProperty.setValue: R|kotlin/Unit|>|(Null(null), ::R|/variableWithImplicitType|, R|<local>/variableWithImplicitType|)
         }

analysis/low-level-api-fir/testdata/lazyResolve/enumEntry.txt

@@ -1,406 +1,406 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(RAW_FIR)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [RAW_FIR] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(RAW_FIR)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @Anno() public final static [RAW_FIR] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @Anno() public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [RAW_FIR] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(RAW_FIR)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @Anno() public final static [RAW_FIR] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @Anno() public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [RAW_FIR] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(RAW_FIR)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @Anno() public final static [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @Anno() public final static [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [RAW_FIR] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(RAW_FIR)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @Anno() public final static [COMPANION_GENERATION] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @Anno() public final static [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [RAW_FIR] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(RAW_FIR)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @Anno() public final static [SUPER_TYPES] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @Anno() public final static [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] fun valueOf([RAW_FIR] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(RAW_FIR)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [RAW_FIR] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [RAW_FIR] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(RAW_FIR)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 TYPES:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [SUPER_TYPES] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [SUPER_TYPES] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public? final? [ResolvedTo(SUPER_TYPES)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [TYPES] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [SUPER_TYPES] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @R|Anno|() public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [SUPER_TYPES] [ContainingClassKey=Foo] fun valueOf([SUPER_TYPES] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(SUPER_TYPES)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [SUPER_TYPES] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [SUPER_TYPES] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(SUPER_TYPES)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 STATUS:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [SUPER_TYPES] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [TYPES] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(SUPER_TYPES)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(TYPES)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [STATUS] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
-        public final static [TYPES] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        @R|Anno|() public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = LAZY_EXPRESSION
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [TYPES] [ContainingClassKey=Foo] fun valueOf([TYPES] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(TYPES)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [TYPES] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [TYPES] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(TYPES)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [SUPER_TYPES] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [TYPES] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(SUPER_TYPES)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(TYPES)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [TYPES] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [TYPES] [ContainingClassKey=Foo] fun valueOf([TYPES] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(TYPES)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [TYPES] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [TYPES] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(TYPES)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(TYPES)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [STATUS] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [STATUS] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(STATUS)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun valueOf([STATUS] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [STATUS] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [STATUS] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(STATUS)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [CONTRACTS] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(CONTRACTS)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun valueOf([STATUS] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] annotation class Anno : R|kotlin/Annotation| {
-        public? [RAW_FIR] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] annotation class Anno : R|kotlin/Annotation| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [STATUS] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [STATUS] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(STATUS)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun valueOf([STATUS] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [STATUS] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [STATUS] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(STATUS)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun valueOf([STATUS] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] enumEntry.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] annotation class Anno : R|kotlin/Annotation| {
-        public [STATUS] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [STATUS] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [STATUS] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(STATUS)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(STATUS)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             LAZY_super<R|kotlin/Enum<Foo>|>
         }
 
-        @R|Anno|() public final static [BODY_RESOLVE] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [BODY_RESOLVE] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] fun valueOf([STATUS] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(STATUS)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [STATUS] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [STATUS] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(STATUS)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(STATUS)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] enumEntry.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] annotation class Anno : R|kotlin/Annotation| {
-        public [BODY_RESOLVE] [ContainingClassKey=Anno] constructor(): R|Anno| {
+FILE: [ResolvedTo(IMPORTS)] enumEntry.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] annotation class Anno : R|kotlin/Annotation| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Anno] constructor(): R|Anno| {
             super<R|kotlin/Any|>()
         }
 
     }
-    public final [BODY_RESOLVE] enum class Foo : R|kotlin/Enum<Foo>| {
-        private [BODY_RESOLVE] [ContainingClassKey=Foo] constructor(): R|Foo| {
+    public final [ResolvedTo(BODY_RESOLVE)] enum class Foo : R|kotlin/Enum<Foo>| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] constructor(): R|Foo| {
             super<R|kotlin/Enum<Foo>|>()
         }
 
-        @R|Anno|() public final static [BODY_RESOLVE] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
-            private [BODY_RESOLVE] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+        @R|Anno|() public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] enum entry ResolveMe: R|Foo| = object : R|Foo| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
                 super<R|Foo|>()
             }
 
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] fun values(): R|kotlin/Array<Foo>| {
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=Foo] fun valueOf([BODY_RESOLVE] value: R|kotlin/String|): R|Foo| {
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] fun valueOf([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|Foo| {
         }
 
-        public final static [BODY_RESOLVE] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
-            public [BODY_RESOLVE] get(): R|kotlin/enums/EnumEntries<Foo>|
+        public final static [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] val entries: R|kotlin/enums/EnumEntries<Foo>|
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/enums/EnumEntries<Foo>|
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/errors/anonymousObjectInInvalidPosition.txt

@@ -1,203 +1,203 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [RAW_FIR] val resolveMe: A = LAZY_EXPRESSION
-        private [RAW_FIR] get(): A
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(RAW_FIR)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(RAW_FIR)] val resolveMe: A = LAZY_EXPRESSION
+        private [ResolvedTo(RAW_FIR)] get(): A
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [RAW_FIR] val resolveMe: A = LAZY_EXPRESSION
-        private [RAW_FIR] get(): A
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(RAW_FIR)] val resolveMe: A = LAZY_EXPRESSION
+        private [ResolvedTo(RAW_FIR)] get(): A
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [COMPILER_REQUIRED_ANNOTATIONS] val resolveMe: A = LAZY_EXPRESSION
-        private [COMPILER_REQUIRED_ANNOTATIONS] get(): A
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val resolveMe: A = LAZY_EXPRESSION
+        private [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): A
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [COMPANION_GENERATION] val resolveMe: A = LAZY_EXPRESSION
-        private [COMPANION_GENERATION] get(): A
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(COMPANION_GENERATION)] val resolveMe: A = LAZY_EXPRESSION
+        private [ResolvedTo(COMPANION_GENERATION)] get(): A
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [SUPER_TYPES] val resolveMe: A = LAZY_EXPRESSION
-        private [SUPER_TYPES] get(): A
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(SUPER_TYPES)] val resolveMe: A = LAZY_EXPRESSION
+        private [ResolvedTo(SUPER_TYPES)] get(): A
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 TYPES:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final? [TYPES] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = LAZY_EXPRESSION
-        private [TYPES] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final? [ResolvedTo(TYPES)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = LAZY_EXPRESSION
+        private [ResolvedTo(TYPES)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 STATUS:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [STATUS] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = LAZY_EXPRESSION
-        private [STATUS] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(STATUS)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = LAZY_EXPRESSION
+        private [ResolvedTo(STATUS)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [EXPECT_ACTUAL_MATCHING] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<<implicit>>()
         }
 
-        public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| {
+        public? open? override [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [EXPECT_ACTUAL_MATCHING] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [ARGUMENTS_OF_ANNOTATIONS] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<<implicit>>()
         }
 
-        public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| {
+        public? open? override [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [ARGUMENTS_OF_ANNOTATIONS] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [CONTRACTS] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(CONTRACTS)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<<implicit>>()
         }
 
-        public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| {
+        public? open? override [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [CONTRACTS] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(CONTRACTS)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [IMPLICIT_TYPES_BODY_RESOLVE] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<<implicit>>()
         }
 
-        public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| {
+        public? open? override [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [IMPLICIT_TYPES_BODY_RESOLVE] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [ANNOTATIONS_ARGUMENTS_MAPPING] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
-        private [RAW_FIR] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : A<Int> {
+        private [ResolvedTo(RAW_FIR)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<<implicit>>()
         }
 
-        public? open? override [RAW_FIR] fun x(): R|kotlin/Unit| {
+        public? open? override [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [ANNOTATIONS_ARGUMENTS_MAPPING] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public? final? [RAW_FIR] interface A<[RAW_FIR] T> : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public? final? [ResolvedTo(RAW_FIR)] interface A<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun x(): R|kotlin/Unit|
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [RAW_FIR] annotations container
-    private final [BODY_RESOLVE] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : R|A<kotlin/Int>| {
-        private [BODY_RESOLVE] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    private final [ResolvedTo(BODY_RESOLVE)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : R|A<kotlin/Int>| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<R|kotlin/Any|>()
         }
 
-        public open override [BODY_RESOLVE] fun x(): R|kotlin/Unit| {
+        public open override [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [BODY_RESOLVE] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public abstract [TYPES] interface A<[TYPES] T> : R|kotlin/Any| {
-        public abstract [TYPES] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(BODY_RESOLVE)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public abstract [ResolvedTo(TYPES)] interface A<[ResolvedTo(TYPES)] T> : R|kotlin/Any| {
+        public abstract [ResolvedTo(TYPES)] fun x(): R|kotlin/Unit|
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] anonymousObjectInInvalidPosition.kt
-    [BODY_RESOLVE] annotations container
-    private final [BODY_RESOLVE] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : R|A<kotlin/Int>| {
-        private [BODY_RESOLVE] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
+FILE: [ResolvedTo(IMPORTS)] anonymousObjectInInvalidPosition.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    private final [ResolvedTo(BODY_RESOLVE)] val resolveMe: <ERROR TYPE REF: Wrong number of type arguments> = ERROR_EXPR(Should have initializer)Null(null) = object : R|A<kotlin/Int>| {
+        private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=<anonymous>] constructor(): R|<anonymous>| {
             super<R|kotlin/Any|>()
         }
 
-        public open override [BODY_RESOLVE] fun x(): R|kotlin/Unit| {
+        public open override [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Unit| {
         }
 
     }
 
-        private [BODY_RESOLVE] get(): <ERROR TYPE REF: Wrong number of type arguments>
-    public abstract [BODY_RESOLVE] interface A<[BODY_RESOLVE] T> : R|kotlin/Any| {
-        public abstract [BODY_RESOLVE] fun x(): R|kotlin/Unit|
+        private [ResolvedTo(BODY_RESOLVE)] get(): <ERROR TYPE REF: Wrong number of type arguments>
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface A<[ResolvedTo(BODY_RESOLVE)] T> : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Unit|
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/functionWithParameter.txt

@@ -1,112 +1,112 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(RAW_FIR)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun resolveMe([RAW_FIR] param: I): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe([ResolvedTo(RAW_FIR)] param: I): <implicit> { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun resolveMe([RAW_FIR] param: I): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe([ResolvedTo(RAW_FIR)] param: I): <implicit> { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe([COMPILER_REQUIRED_ANNOTATIONS] param: I): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe([ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] param: I): <implicit> { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [COMPANION_GENERATION] fun resolveMe([COMPANION_GENERATION] param: I): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe([ResolvedTo(COMPANION_GENERATION)] param: I): <implicit> { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [SUPER_TYPES] fun resolveMe([SUPER_TYPES] param: I): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe([ResolvedTo(SUPER_TYPES)] param: I): <implicit> { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public? final? [TYPES] fun resolveMe([TYPES] param: R|I|): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(TYPES)] fun resolveMe([ResolvedTo(TYPES)] param: R|I|): <implicit> { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [STATUS] fun resolveMe([STATUS] param: R|I|): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(STATUS)] fun resolveMe([ResolvedTo(STATUS)] param: R|I|): <implicit> { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe([EXPECT_ACTUAL_MATCHING] param: R|I|): <implicit> {
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe([ResolvedTo(EXPECT_ACTUAL_MATCHING)] param: R|I|): <implicit> {
         ^resolveMe Unit#
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe([ARGUMENTS_OF_ANNOTATIONS] param: R|I|): <implicit> {
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe([ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] param: R|I|): <implicit> {
         ^resolveMe Unit#
     }
 
 CONTRACTS:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [CONTRACTS] fun resolveMe([CONTRACTS] param: R|I|): <implicit> {
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe([ResolvedTo(CONTRACTS)] param: R|I|): <implicit> {
         ^resolveMe Unit#
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe([IMPLICIT_TYPES_BODY_RESOLVE] param: R|I|): R|kotlin/Unit| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] param: R|I|): R|kotlin/Unit| {
         ^resolveMe Q|kotlin/Unit|
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe([ANNOTATIONS_ARGUMENTS_MAPPING] param: R|I|): R|kotlin/Unit| {
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe([ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] param: R|I|): R|kotlin/Unit| {
         ^resolveMe Q|kotlin/Unit|
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] functionWithParameter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] interface I : R|kotlin/Any| {
     }
-    public final [BODY_RESOLVE] fun resolveMe([BODY_RESOLVE] param: R|I|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe([ResolvedTo(BODY_RESOLVE)] param: R|I|): R|kotlin/Unit| {
         ^resolveMe Q|kotlin/Unit|
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] functionWithParameter.kt
-    [BODY_RESOLVE] annotations container
-    public abstract [BODY_RESOLVE] interface I : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] functionWithParameter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface I : R|kotlin/Any| {
     }
-    public final [BODY_RESOLVE] fun resolveMe([BODY_RESOLVE] param: R|I|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe([ResolvedTo(BODY_RESOLVE)] param: R|I|): R|kotlin/Unit| {
         ^resolveMe Q|kotlin/Unit|
     }

analysis/low-level-api-fir/testdata/lazyResolve/functions/functionCallWithGenericResult.txt

@@ -1,186 +1,186 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(RAW_FIR)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: <implicit> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: <implicit> = bar#()
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: <implicit> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: <implicit> = bar#()
     }
 
 CONTRACTS:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: <implicit> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: <implicit> = bar#()
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: <implicit> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: <implicit> = bar#()
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): Foo<String>? { LAZY_BLOCK }
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: <implicit> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): Foo<String>? { LAZY_BLOCK }
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: <implicit> = bar#()
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [CONTRACTS] fun bar(): R|Foo<kotlin/String>?| {
+    public final [ResolvedTo(CONTRACTS)] fun bar(): R|Foo<kotlin/String>?| {
         ^bar Null(null)
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval x: R|Foo<kotlin/String>?| = R|/bar|()
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval x: R|Foo<kotlin/String>?| = R|/bar|()
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] functionCallWithGenericResult.kt
-    [BODY_RESOLVE] annotations container
-    public open [BODY_RESOLVE] class Foo<[BODY_RESOLVE] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=Foo] constructor<[BODY_RESOLVE] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionCallWithGenericResult.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public open [ResolvedTo(BODY_RESOLVE)] class Foo<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] constructor<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
             super<R|kotlin/Any|>()
         }
 
     }
-    public final [BODY_RESOLVE] fun bar(): R|Foo<kotlin/String>?| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun bar(): R|Foo<kotlin/String>?| {
         ^bar Null(null)
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval x: R|Foo<kotlin/String>?| = R|/bar|()
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval x: R|Foo<kotlin/String>?| = R|/bar|()
     }

analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithGenericExpectedTypeInside.txt

@@ -1,270 +1,270 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(RAW_FIR)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: Foo<String> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: Foo<String> = bar#()
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: Foo<String> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: Foo<String> = bar#()
     }
 
 CONTRACTS:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: Foo<String> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: Foo<String> = bar#()
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: Foo<String> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: Foo<String> = bar#()
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class Foo<[RAW_FIR] T : CharSequence> : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Foo] constructor<[RAW_FIR] T : CharSequence>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class Foo<[ResolvedTo(RAW_FIR)] T : CharSequence> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Foo] constructor<[ResolvedTo(RAW_FIR)] T : CharSequence>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? [RAW_FIR] class Bar : Foo<String> {
-        public? [RAW_FIR] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public? final? [ResolvedTo(RAW_FIR)] class Bar : Foo<String> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public? final? [RAW_FIR] fun bar(): <implicit> { LAZY_BLOCK }
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
-        [RAW_FIR] lval x: Foo<String> = bar#()
+    public? final? [ResolvedTo(RAW_FIR)] fun bar(): <implicit> { LAZY_BLOCK }
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(RAW_FIR)] lval x: Foo<String> = bar#()
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class Foo<[TYPES] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=Foo] constructor<[TYPES] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class Foo<[ResolvedTo(TYPES)] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=Foo] constructor<[ResolvedTo(TYPES)] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public final [TYPES] class Bar : R|Foo<kotlin/String>| {
-        public [STATUS] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public final [ResolvedTo(TYPES)] class Bar : R|Foo<kotlin/String>| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             LAZY_super<<implicit>>
         }
 
     }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun bar(): R|Bar| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun bar(): R|Bar| {
         ^bar R|/Bar.Bar|()
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval x: R|Foo<kotlin/String>| = R|/bar|()
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval x: R|Foo<kotlin/String>| = R|/bar|()
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] functionWithGenericExpectedTypeInside.kt
-    [BODY_RESOLVE] annotations container
-    public open [BODY_RESOLVE] class Foo<[BODY_RESOLVE] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=Foo] constructor<[BODY_RESOLVE] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
+FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public open [ResolvedTo(BODY_RESOLVE)] class Foo<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/CharSequence|> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Foo] constructor<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/CharSequence|>(): R|Foo<T>| {
             super<R|kotlin/Any|>()
         }
 
     }
-    public final [BODY_RESOLVE] class Bar : R|Foo<kotlin/String>| {
-        public [BODY_RESOLVE] [ContainingClassKey=Bar] constructor(): R|Bar| {
+    public final [ResolvedTo(BODY_RESOLVE)] class Bar : R|Foo<kotlin/String>| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Bar] constructor(): R|Bar| {
             super<R|Foo<kotlin/String>|>()
         }
 
     }
-    public final [BODY_RESOLVE] fun bar(): R|Bar| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun bar(): R|Bar| {
         ^bar R|/Bar.Bar|()
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        [BODY_RESOLVE] lval x: R|Foo<kotlin/String>| = R|/bar|()
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        [ResolvedTo(BODY_RESOLVE)] lval x: R|Foo<kotlin/String>| = R|/bar|()
     }

analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithTypeParameters.txt

@@ -1,77 +1,77 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun <[RAW_FIR] T : Int, [RAW_FIR] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun <[RAW_FIR] T : Int, [RAW_FIR] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun <[COMPILER_REQUIRED_ANNOTATIONS] T : Int, [COMPILER_REQUIRED_ANNOTATIONS] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun <[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T : Int, [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun <[COMPANION_GENERATION] T : Int, [COMPANION_GENERATION] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun <[ResolvedTo(COMPANION_GENERATION)] T : Int, [ResolvedTo(COMPANION_GENERATION)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun <[SUPER_TYPES] T : Int, [SUPER_TYPES] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun <[ResolvedTo(SUPER_TYPES)] T : Int, [ResolvedTo(SUPER_TYPES)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun <[TYPES] T : R|kotlin/Int|, [TYPES] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun <[ResolvedTo(TYPES)] T : R|kotlin/Int|, [ResolvedTo(TYPES)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun <[STATUS] T : R|kotlin/Int|, [STATUS] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun <[ResolvedTo(STATUS)] T : R|kotlin/Int|, [ResolvedTo(STATUS)] K> resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun <[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun <[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T : R|kotlin/Int|, [ResolvedTo(EXPECT_ACTUAL_MATCHING)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun <[ARGUMENTS_OF_ANNOTATIONS] T : R|kotlin/Int|, [ARGUMENTS_OF_ANNOTATIONS] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun <[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T : R|kotlin/Int|, [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 CONTRACTS:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun <[CONTRACTS] T : R|kotlin/Int|, [CONTRACTS] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] T : R|kotlin/Int|, [ResolvedTo(CONTRACTS)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun <[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun <[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun <[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T : R|kotlin/Int|, [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> resolveMe(): R|kotlin/Unit| {
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] functionWithTypeParameters.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] functionWithTypeParameters.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> resolveMe(): R|kotlin/Unit| {
     }

analysis/low-level-api-fir/testdata/lazyResolve/lambdaAsSAMInterface.txt

@@ -1,260 +1,260 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(RAW_FIR)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
-        testMe#(<L> = [STATUS] testMe@fun <implicit>.<anonymous>([RAW_FIR] b: <implicit>): <implicit> <inline=Unknown>  {
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
+        testMe#(<L> = [ResolvedTo(RAW_FIR)] testMe@fun <implicit>.<anonymous>([ResolvedTo(RAW_FIR)] b: <implicit>): <implicit> <inline=Unknown>  {
             b#
         }
         )
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
-        testMe#(<L> = [STATUS] testMe@fun <implicit>.<anonymous>([RAW_FIR] b: <implicit>): <implicit> <inline=Unknown>  {
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
+        testMe#(<L> = [ResolvedTo(RAW_FIR)] testMe@fun <implicit>.<anonymous>([ResolvedTo(RAW_FIR)] b: <implicit>): <implicit> <inline=Unknown>  {
             b#
         }
         )
     }
 
 CONTRACTS:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
-        testMe#(<L> = [STATUS] testMe@fun <implicit>.<anonymous>([RAW_FIR] b: <implicit>): <implicit> <inline=Unknown>  {
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
+        testMe#(<L> = [ResolvedTo(RAW_FIR)] testMe@fun <implicit>.<anonymous>([ResolvedTo(RAW_FIR)] b: <implicit>): <implicit> <inline=Unknown>  {
             b#
         }
         )
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        testMe#(<L> = [STATUS] testMe@fun <implicit>.<anonymous>([RAW_FIR] b: <implicit>): <implicit> <inline=Unknown>  {
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        testMe#(<L> = [ResolvedTo(RAW_FIR)] testMe@fun <implicit>.<anonymous>([ResolvedTo(RAW_FIR)] b: <implicit>): <implicit> <inline=Unknown>  {
             b#
         }
         )
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? final? fun [RAW_FIR] interface Foo : R|kotlin/Any| {
-        public? final? [RAW_FIR] fun foo([RAW_FIR] a: Arg): Arg
+    public? final? fun [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
+        public? final? [ResolvedTo(RAW_FIR)] fun foo([ResolvedTo(RAW_FIR)] a: Arg): Arg
 
     }
-    public? final? [RAW_FIR] fun testMe([RAW_FIR] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
-        testMe#(<L> = [STATUS] testMe@fun <implicit>.<anonymous>([RAW_FIR] b: <implicit>): <implicit> <inline=Unknown>  {
+    public? final? [ResolvedTo(RAW_FIR)] fun testMe([ResolvedTo(RAW_FIR)] f: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
+        testMe#(<L> = [ResolvedTo(RAW_FIR)] testMe@fun <implicit>.<anonymous>([ResolvedTo(RAW_FIR)] b: <implicit>): <implicit> <inline=Unknown>  {
             b#
         }
         )
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class Arg : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class Arg : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public abstract fun [SUPER_TYPES] interface Foo : R|kotlin/Any| {
-        public abstract [STATUS] fun foo([STATUS] a: R|foo/Arg|): R|foo/Arg|
+    public abstract fun [ResolvedTo(SUPER_TYPES)] interface Foo : R|kotlin/Any| {
+        public abstract [ResolvedTo(STATUS)] fun foo([ResolvedTo(STATUS)] a: R|foo/Arg|): R|foo/Arg|
 
     }
-    public final [CONTRACTS] fun testMe([CONTRACTS] f: R|foo/Foo|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun testMe([ResolvedTo(CONTRACTS)] f: R|foo/Foo|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        R|foo/testMe|(<L> = [BODY_RESOLVE] [MatchingParameterFunctionTypeKey=foo/Foo] testMe@fun <anonymous>([BODY_RESOLVE] b: R|foo/Arg|): R|foo/Arg| <inline=NoInline>  {
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        R|foo/testMe|(<L> = [ResolvedTo(BODY_RESOLVE)] [MatchingParameterFunctionTypeKey=foo/Foo] testMe@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] b: R|foo/Arg|): R|foo/Arg| <inline=NoInline>  {
             ^ R|<local>/b|
         }
         )
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] lambdaAsSAMInterface.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class Arg : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
+FILE: [ResolvedTo(IMPORTS)] lambdaAsSAMInterface.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class Arg : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Arg] constructor(): R|foo/Arg| {
             super<R|kotlin/Any|>()
         }
 
     }
-    public abstract fun [BODY_RESOLVE] interface Foo : R|kotlin/Any| {
-        public abstract [BODY_RESOLVE] fun foo([BODY_RESOLVE] a: R|foo/Arg|): R|foo/Arg|
+    public abstract fun [ResolvedTo(BODY_RESOLVE)] interface Foo : R|kotlin/Any| {
+        public abstract [ResolvedTo(BODY_RESOLVE)] fun foo([ResolvedTo(BODY_RESOLVE)] a: R|foo/Arg|): R|foo/Arg|
 
     }
-    public final [BODY_RESOLVE] fun testMe([BODY_RESOLVE] f: R|foo/Foo|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun testMe([ResolvedTo(BODY_RESOLVE)] f: R|foo/Foo|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
-        R|foo/testMe|(<L> = [BODY_RESOLVE] [MatchingParameterFunctionTypeKey=foo/Foo] testMe@fun <anonymous>([BODY_RESOLVE] b: R|foo/Arg|): R|foo/Arg| <inline=NoInline>  {
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
+        R|foo/testMe|(<L> = [ResolvedTo(BODY_RESOLVE)] [MatchingParameterFunctionTypeKey=foo/Foo] testMe@fun <anonymous>([ResolvedTo(BODY_RESOLVE)] b: R|foo/Arg|): R|foo/Arg| <inline=NoInline>  {
             ^ R|<local>/b|
         }
         )

analysis/low-level-api-fir/testdata/lazyResolve/parameterOfNonLocalSetter.txt

@@ -1,209 +1,209 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(RAW_FIR)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] var x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=X] get(): Int
-            public? [RAW_FIR] [ContainingClassKey=X] set([RAW_FIR] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] var x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] get(): Int
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] set([ResolvedTo(RAW_FIR)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] var x: Int = LAZY_EXPRESSION
-            public? [RAW_FIR] [ContainingClassKey=X] get(): Int
-            public? [RAW_FIR] [ContainingClassKey=X] set([RAW_FIR] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] var x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] get(): Int
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] set([ResolvedTo(RAW_FIR)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPILER_REQUIRED_ANNOTATIONS] var x: Int = LAZY_EXPRESSION
-            public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=X] get(): Int
-            public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=X] set([COMPILER_REQUIRED_ANNOTATIONS] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] var x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=X] get(): Int
+            public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=X] set([ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPANION_GENERATION] var x: Int = LAZY_EXPRESSION
-            public? [COMPANION_GENERATION] [ContainingClassKey=X] get(): Int
-            public? [COMPANION_GENERATION] [ContainingClassKey=X] set([COMPANION_GENERATION] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPANION_GENERATION)] var x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=X] get(): Int
+            public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=X] set([ResolvedTo(COMPANION_GENERATION)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [SUPER_TYPES] var x: Int = LAZY_EXPRESSION
-            public? [SUPER_TYPES] [ContainingClassKey=X] get(): Int
-            public? [SUPER_TYPES] [ContainingClassKey=X] set([SUPER_TYPES] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] var x: Int = LAZY_EXPRESSION
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=X] get(): Int
+            public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=X] set([ResolvedTo(SUPER_TYPES)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] class X : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [TYPES] var x: R|kotlin/Int| = LAZY_EXPRESSION
-            public? [TYPES] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public? [TYPES] [ContainingClassKey=X] set([TYPES] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(TYPES)] var x: R|kotlin/Int| = LAZY_EXPRESSION
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public? [ResolvedTo(TYPES)] [ContainingClassKey=X] set([ResolvedTo(TYPES)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class X : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] var x: R|kotlin/Int| = LAZY_EXPRESSION
-            public [STATUS] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [STATUS] [ContainingClassKey=X] set([STATUS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] var x: R|kotlin/Int| = LAZY_EXPRESSION
+            public [ResolvedTo(STATUS)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=X] set([ResolvedTo(STATUS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class X : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [EXPECT_ACTUAL_MATCHING] var x: R|kotlin/Int| = IntegerLiteral(2)
-            public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=X] set([EXPECT_ACTUAL_MATCHING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] var x: R|kotlin/Int| = IntegerLiteral(2)
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=X] set([ResolvedTo(EXPECT_ACTUAL_MATCHING)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Unit#
             }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ARGUMENTS_OF_ANNOTATIONS] var x: R|kotlin/Int| = IntegerLiteral(2)
-            public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=X] set([ARGUMENTS_OF_ANNOTATIONS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] var x: R|kotlin/Int| = IntegerLiteral(2)
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=X] set([ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Unit#
             }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [CONTRACTS] var x: R|kotlin/Int| = IntegerLiteral(2)
-            public [CONTRACTS] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [CONTRACTS] [ContainingClassKey=X] set([CONTRACTS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(CONTRACTS)] var x: R|kotlin/Int| = IntegerLiteral(2)
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(CONTRACTS)] [ContainingClassKey=X] set([ResolvedTo(CONTRACTS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Unit#
             }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [IMPLICIT_TYPES_BODY_RESOLVE] var x: R|kotlin/Int| = IntegerLiteral(2)
-            public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=X] set([IMPLICIT_TYPES_BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] var x: R|kotlin/Int| = IntegerLiteral(2)
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=X] set([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Unit#
             }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ANNOTATIONS_ARGUMENTS_MAPPING] var x: R|kotlin/Int| = IntegerLiteral(2)
-            public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=X] set([ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] var x: R|kotlin/Int| = IntegerLiteral(2)
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=X] set([ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Unit#
             }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [BODY_RESOLVE] var x: R|kotlin/Int| = Int(2)
-            public [BODY_RESOLVE] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [BODY_RESOLVE] [ContainingClassKey=X] set([BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] var x: R|kotlin/Int| = Int(2)
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] set([ResolvedTo(BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Q|kotlin/Unit|
             }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] parameterOfNonLocalSetter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class X : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] parameterOfNonLocalSetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class X : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] constructor(): R|X| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] var x: R|kotlin/Int| = Int(2)
-            public [BODY_RESOLVE] [ContainingClassKey=X] get(): R|kotlin/Int|
-            public [BODY_RESOLVE] [ContainingClassKey=X] set([BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] var x: R|kotlin/Int| = Int(2)
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] get(): R|kotlin/Int|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] set([ResolvedTo(BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
                 ^ Q|kotlin/Unit|
             }
 

analysis/low-level-api-fir/testdata/lazyResolve/properties/propertyWithTypeParameters.txt

@@ -1,98 +1,98 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] val <[RAW_FIR] T : Int, [RAW_FIR] K> T.resolveMe: K
-        public? [RAW_FIR] get(): K { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] val <[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> T.resolveMe: K
+        public? [ResolvedTo(RAW_FIR)] get(): K { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] val <[RAW_FIR] T : Int, [RAW_FIR] K> T.resolveMe: K
-        public? [RAW_FIR] get(): K { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] val <[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> T.resolveMe: K
+        public? [ResolvedTo(RAW_FIR)] get(): K { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] val <[COMPILER_REQUIRED_ANNOTATIONS] T : Int, [COMPILER_REQUIRED_ANNOTATIONS] K> T.resolveMe: K
-        public? [COMPILER_REQUIRED_ANNOTATIONS] get(): K { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val <[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T : Int, [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] K> T.resolveMe: K
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): K { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] val <[COMPANION_GENERATION] T : Int, [COMPANION_GENERATION] K> T.resolveMe: K
-        public? [COMPANION_GENERATION] get(): K { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] val <[ResolvedTo(COMPANION_GENERATION)] T : Int, [ResolvedTo(COMPANION_GENERATION)] K> T.resolveMe: K
+        public? [ResolvedTo(COMPANION_GENERATION)] get(): K { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] val <[SUPER_TYPES] T : Int, [SUPER_TYPES] K> T.resolveMe: K
-        public? [SUPER_TYPES] get(): K { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] val <[ResolvedTo(SUPER_TYPES)] T : Int, [ResolvedTo(SUPER_TYPES)] K> T.resolveMe: K
+        public? [ResolvedTo(SUPER_TYPES)] get(): K { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] val <[TYPES] T : R|kotlin/Int|, [TYPES] K> R|T|.resolveMe: R|K|
-        public? [TYPES] get(): R|K| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] val <[ResolvedTo(TYPES)] T : R|kotlin/Int|, [ResolvedTo(TYPES)] K> R|T|.resolveMe: R|K|
+        public? [ResolvedTo(TYPES)] get(): R|K| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] val <[STATUS] T : R|kotlin/Int|, [STATUS] K> R|T|.resolveMe: R|K|
-        public [STATUS] get(): R|K| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] val <[ResolvedTo(STATUS)] T : R|kotlin/Int|, [ResolvedTo(STATUS)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(STATUS)] get(): R|K| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] val <[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> R|T|.resolveMe: R|K|
-        public [EXPECT_ACTUAL_MATCHING] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val <[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T : R|kotlin/Int|, [ResolvedTo(EXPECT_ACTUAL_MATCHING)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): R|K| {
             ^ TODO#()
         }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] val <[ARGUMENTS_OF_ANNOTATIONS] T : R|kotlin/Int|, [ARGUMENTS_OF_ANNOTATIONS] K> R|T|.resolveMe: R|K|
-        public [ARGUMENTS_OF_ANNOTATIONS] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val <[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T : R|kotlin/Int|, [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): R|K| {
             ^ TODO#()
         }
 
 CONTRACTS:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] val <[CONTRACTS] T : R|kotlin/Int|, [CONTRACTS] K> R|T|.resolveMe: R|K|
-        public [CONTRACTS] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] val <[ResolvedTo(CONTRACTS)] T : R|kotlin/Int|, [ResolvedTo(CONTRACTS)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(CONTRACTS)] get(): R|K| {
             ^ TODO#()
         }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] val <[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> R|T|.resolveMe: R|K|
-        public [IMPLICIT_TYPES_BODY_RESOLVE] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val <[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|K| {
             ^ TODO#()
         }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] val <[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> R|T|.resolveMe: R|K|
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val <[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T : R|kotlin/Int|, [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): R|K| {
             ^ TODO#()
         }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] val <[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> R|T|.resolveMe: R|K|
-        public [BODY_RESOLVE] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] val <[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|K| {
             ^ R|kotlin/TODO|()
         }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] propertyWithTypeParameters.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] val <[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> R|T|.resolveMe: R|K|
-        public [BODY_RESOLVE] get(): R|K| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithTypeParameters.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] val <[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> R|T|.resolveMe: R|K|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|K| {
             ^ R|kotlin/TODO|()
         }

analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetter.txt

@@ -1,132 +1,132 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetter#)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetter#)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetter#)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetter#)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetter#)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val withGetter: Int
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val withGetter: Int
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/withGetter|)
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [CONTRACTS] val withGetter: R|kotlin/Int|
-        public [CONTRACTS] get(): R|kotlin/Int| {
+    public final [ResolvedTo(CONTRACTS)] val withGetter: R|kotlin/Int|
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int| {
             ^ IntegerLiteral(42)
         }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] propertyWithGetter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/withGetter|)
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] val withGetter: R|kotlin/Int|
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] val withGetter: R|kotlin/Int|
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ Int(42)
         }

analysis/low-level-api-fir/testdata/lazyResolve/propertyWithGetterAndSetter.txt

@@ -1,157 +1,157 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetterAndSetter#)
         withGetterAndSetter# = IntegerLiteral(123)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetterAndSetter#)
         withGetterAndSetter# = IntegerLiteral(123)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetterAndSetter#)
         withGetterAndSetter# = IntegerLiteral(123)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetterAndSetter#)
         withGetterAndSetter# = IntegerLiteral(123)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(withGetterAndSetter#)
         withGetterAndSetter# = IntegerLiteral(123)
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] var withGetterAndSetter: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int { LAZY_BLOCK }
-        public? [RAW_FIR] set([RAW_FIR] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] var withGetterAndSetter: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int { LAZY_BLOCK }
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] value: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/withGetterAndSetter|)
         R|/withGetterAndSetter| = Int(123)
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [CONTRACTS] var withGetterAndSetter: R|kotlin/Int| = IntegerLiteral(42)
-        public [CONTRACTS] get(): R|kotlin/Int| {
+    public final [ResolvedTo(CONTRACTS)] var withGetterAndSetter: R|kotlin/Int| = IntegerLiteral(42)
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int| {
             ^ field#
         }
-        public [CONTRACTS] set([CONTRACTS] value: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(CONTRACTS)] set([ResolvedTo(CONTRACTS)] value: R|kotlin/Int|): R|kotlin/Unit| {
             field# = value#
         }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] propertyWithGetterAndSetter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithGetterAndSetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/withGetterAndSetter|)
         R|/withGetterAndSetter| = Int(123)
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] [IsReferredViaField=true] var withGetterAndSetter: R|kotlin/Int| = Int(42)
-        public [BODY_RESOLVE] get(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] [IsReferredViaField=true] var withGetterAndSetter: R|kotlin/Int| = Int(42)
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int| {
             ^ F|/withGetterAndSetter|
         }
-        public [BODY_RESOLVE] set([BODY_RESOLVE] value: R|kotlin/Int|): R|kotlin/Unit| {
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/Int|): R|kotlin/Unit| {
             F|/withGetterAndSetter| = R|<local>/value|
         }

analysis/low-level-api-fir/testdata/lazyResolve/propertyWithInitializer.txt

@@ -1,112 +1,112 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(RAW_FIR)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 IMPORTS:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 SUPER_TYPES:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 TYPES:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 STATUS:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(property#)
     }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(property#)
     }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 CONTRACTS:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(property#)
     }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(property#)
     }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(property#)
     }
-    public? final? [RAW_FIR] val property: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
+    public? final? [ResolvedTo(RAW_FIR)] val property: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
 
 BODY_RESOLVE:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         <Unresolved name: receive>#(R|/property|)
     }
-    public final [CONTRACTS] val property: R|kotlin/Int| = IntegerLiteral(10)
-        public [CONTRACTS] get(): R|kotlin/Int|
+    public final [ResolvedTo(CONTRACTS)] val property: R|kotlin/Int| = IntegerLiteral(10)
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int|
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] propertyWithInitializer.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] propertyWithInitializer.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         <Unresolved name: receive>#(R|/property|)
     }
-    public final [BODY_RESOLVE] val property: R|kotlin/Int| = Int(10)
-        public [BODY_RESOLVE] get(): R|kotlin/Int|
+    public final [ResolvedTo(BODY_RESOLVE)] val property: R|kotlin/Int| = Int(10)
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|

analysis/low-level-api-fir/testdata/lazyResolve/secondaryConstructor.txt

@@ -1,159 +1,159 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(A#(IntegerLiteral(42)))
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(A#(IntegerLiteral(42)))
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(A#(IntegerLiteral(42)))
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(A#(IntegerLiteral(42)))
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(A#(IntegerLiteral(42)))
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: A): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor([RAW_FIR] x: Int): R|A| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: A): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor([ResolvedTo(RAW_FIR)] x: Int): R|A| { LAZY_BLOCK }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/A.A|(Int(42)))
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|A|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|A|): R|kotlin/Unit| {
     }
-    public final [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor([STATUS] x: R|kotlin/Int|): R|A| { LAZY_BLOCK }
+    public final [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor([ResolvedTo(STATUS)] x: R|kotlin/Int|): R|A| { LAZY_BLOCK }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] secondaryConstructor.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] secondaryConstructor.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/A.A|(Int(42)))
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|A|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|A|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=A] constructor([BODY_RESOLVE] x: R|kotlin/Int|): R|A| {
+    public final [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor([ResolvedTo(BODY_RESOLVE)] x: R|kotlin/Int|): R|A| {
             super<R|kotlin/Any|>()
-            [BODY_RESOLVE] lval a: R|kotlin/Int| = R|<local>/x|
+            [ResolvedTo(BODY_RESOLVE)] lval a: R|kotlin/Int| = R|<local>/x|
         }
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/superTypes.txt

@@ -1,307 +1,307 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(RAW_FIR)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [RAW_FIR] class resolveMe : A {
-        public? [RAW_FIR] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(RAW_FIR)] class resolveMe : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<A>
         }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [RAW_FIR] class resolveMe : A {
-        public? [RAW_FIR] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(RAW_FIR)] class resolveMe : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<A>
         }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [COMPILER_REQUIRED_ANNOTATIONS] class resolveMe : A {
-        public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class resolveMe : A {
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<A>
         }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [COMPANION_GENERATION] class resolveMe : A {
-        public? [COMPANION_GENERATION] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(COMPANION_GENERATION)] class resolveMe : A {
+        public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<A>
         }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class A : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [SUPER_TYPES] class resolveMe : R|A| {
-        public? [SUPER_TYPES] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(SUPER_TYPES)] class resolveMe : R|A| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<A>
         }
 
     }
 
 TYPES:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public? open [SUPER_TYPES] class A : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(SUPER_TYPES)] class A : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public? open [TYPES] class resolveMe : R|A| {
-        public? [TYPES] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public? open [ResolvedTo(TYPES)] class resolveMe : R|A| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<R|A|>
         }
 
     }
 
 STATUS:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [STATUS] class resolveMe : R|A| {
-        public [STATUS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(STATUS)] class resolveMe : R|A| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<R|A|>
         }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [EXPECT_ACTUAL_MATCHING] class resolveMe : R|A| {
-        public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class resolveMe : R|A| {
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [ARGUMENTS_OF_ANNOTATIONS] class resolveMe : R|A| {
-        public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class resolveMe : R|A| {
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [CONTRACTS] class resolveMe : R|A| {
-        public [CONTRACTS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(CONTRACTS)] class resolveMe : R|A| {
+        public [ResolvedTo(CONTRACTS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [IMPLICIT_TYPES_BODY_RESOLVE] class resolveMe : R|A| {
-        public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class resolveMe : R|A| {
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [TYPES] class A : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(TYPES)] class A : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [ANNOTATIONS_ARGUMENTS_MAPPING] class resolveMe : R|A| {
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class resolveMe : R|A| {
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] superTypes.kt
-    [RAW_FIR] annotations container
-    public open [STATUS] class A : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(STATUS)] class A : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<R|kotlin/Any|>
         }
 
     }
-    public? open [RAW_FIR] class B : A {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<A>
         }
 
     }
-    public open [BODY_RESOLVE] class resolveMe : R|A| {
-        public [BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(BODY_RESOLVE)] class resolveMe : R|A| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] superTypes.kt
-    [BODY_RESOLVE] annotations container
-    public open [BODY_RESOLVE] class A : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=A] constructor(): R|A| {
+FILE: [ResolvedTo(IMPORTS)] superTypes.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public open [ResolvedTo(BODY_RESOLVE)] class A : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|kotlin/Any|>()
         }
 
     }
-    public open [BODY_RESOLVE] class B : R|A| {
-        public [BODY_RESOLVE] [ContainingClassKey=B] constructor(): R|B| {
+    public open [ResolvedTo(BODY_RESOLVE)] class B : R|A| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=B] constructor(): R|B| {
             super<R|A|>()
         }
 
     }
-    public open [BODY_RESOLVE] class resolveMe : R|A| {
-        public [BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+    public open [ResolvedTo(BODY_RESOLVE)] class resolveMe : R|A| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|A|>()
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/superTypesLoop.txt

@@ -1,391 +1,391 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class resolveMe : C {
-        public? [RAW_FIR] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(RAW_FIR)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class resolveMe : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class A : B {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : B {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : C {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class C : A {
-        public? [RAW_FIR] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(RAW_FIR)] class C : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [RAW_FIR] class resolveMe : C {
-        public? [RAW_FIR] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(RAW_FIR)] class resolveMe : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class A : B {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : B {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : C {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class C : A {
-        public? [RAW_FIR] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(RAW_FIR)] class C : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [COMPILER_REQUIRED_ANNOTATIONS] class resolveMe : C {
-        public? [COMPILER_REQUIRED_ANNOTATIONS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] class resolveMe : C {
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class A : B {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : B {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : C {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class C : A {
-        public? [RAW_FIR] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(RAW_FIR)] class C : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [COMPANION_GENERATION] class resolveMe : C {
-        public? [COMPANION_GENERATION] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(COMPANION_GENERATION)] class resolveMe : C {
+        public? [ResolvedTo(COMPANION_GENERATION)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class A : B {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : B {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : C {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : C {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class C : A {
-        public? [RAW_FIR] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(RAW_FIR)] class C : A {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [SUPER_TYPES] class resolveMe : R|C| {
-        public? [SUPER_TYPES] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(SUPER_TYPES)] class resolveMe : R|C| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [RAW_FIR] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public? [RAW_FIR] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(RAW_FIR)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 TYPES:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public? open [TYPES] class resolveMe : R|C| {
-        public? [TYPES] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? open [ResolvedTo(TYPES)] class resolveMe : R|C| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<R|C|>
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public? open [SUPER_TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public? [SUPER_TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public? open [ResolvedTo(SUPER_TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<A>
         }
 
     }
 
 STATUS:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [STATUS] class resolveMe : R|C| {
-        public [STATUS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(STATUS)] class resolveMe : R|C| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             LAZY_super<R|C|>
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [EXPECT_ACTUAL_MATCHING] class resolveMe : R|C| {
-        public [EXPECT_ACTUAL_MATCHING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(EXPECT_ACTUAL_MATCHING)] class resolveMe : R|C| {
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [ARGUMENTS_OF_ANNOTATIONS] class resolveMe : R|C| {
-        public [ARGUMENTS_OF_ANNOTATIONS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] class resolveMe : R|C| {
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [CONTRACTS] class resolveMe : R|C| {
-        public [CONTRACTS] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(CONTRACTS)] class resolveMe : R|C| {
+        public [ResolvedTo(CONTRACTS)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [IMPLICIT_TYPES_BODY_RESOLVE] class resolveMe : R|C| {
-        public [IMPLICIT_TYPES_BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] class resolveMe : R|C| {
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [ANNOTATIONS_ARGUMENTS_MAPPING] class resolveMe : R|C| {
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] class resolveMe : R|C| {
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [TYPES] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [TYPES] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(TYPES)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] superTypesLoop.kt
-    [RAW_FIR] annotations container
-    public open [BODY_RESOLVE] class resolveMe : R|C| {
-        public [BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public open [ResolvedTo(BODY_RESOLVE)] class resolveMe : R|C| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public? open [RAW_FIR] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public? [RAW_FIR] [ContainingClassKey=A] constructor(): R|A| {
+    public? open [ResolvedTo(RAW_FIR)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=A] constructor(): R|A| {
             LAZY_super<B>
         }
 
     }
-    public? open [RAW_FIR] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public? [RAW_FIR] [ContainingClassKey=B] constructor(): R|B| {
+    public? open [ResolvedTo(RAW_FIR)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=B] constructor(): R|B| {
             LAZY_super<C>
         }
 
     }
-    public open [STATUS] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [STATUS] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(STATUS)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=C] constructor(): R|C| {
             LAZY_super<R|A|>
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] superTypesLoop.kt
-    [BODY_RESOLVE] annotations container
-    public open [BODY_RESOLVE] class resolveMe : R|C| {
-        public [BODY_RESOLVE] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
+FILE: [ResolvedTo(IMPORTS)] superTypesLoop.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public open [ResolvedTo(BODY_RESOLVE)] class resolveMe : R|C| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=resolveMe] constructor(): R|resolveMe| {
             super<R|C|>()
         }
 
     }
-    public open [BODY_RESOLVE] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
-        public [BODY_RESOLVE] [ContainingClassKey=A] constructor(): R|A| {
+    public open [ResolvedTo(BODY_RESOLVE)] class A : <ERROR TYPE REF: Loop in supertype: /A -> /B> {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=A] constructor(): R|A| {
             super<R|B|>()
         }
 
     }
-    public open [BODY_RESOLVE] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
-        public [BODY_RESOLVE] [ContainingClassKey=B] constructor(): R|B| {
+    public open [ResolvedTo(BODY_RESOLVE)] class B : <ERROR TYPE REF: Loop in supertype: /B -> /C> {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=B] constructor(): R|B| {
             super<R|C|>()
         }
 
     }
-    public open [BODY_RESOLVE] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
-        public [BODY_RESOLVE] [ContainingClassKey=C] constructor(): R|C| {
+    public open [ResolvedTo(BODY_RESOLVE)] class C : <ERROR TYPE REF: Loop in supertype: /C -> /A> {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=C] constructor(): R|C| {
             super<R|A|>()
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctions.txt

@@ -1,118 +1,118 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [CONTRACTS] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(CONTRACTS)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] topLevelFunctions.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctions.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }

analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithExpressionBodyAndExplicitType.txt

@@ -1,118 +1,118 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): String { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): String { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [CONTRACTS] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(CONTRACTS)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithExpressionBodyAndExplicitType.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }

analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt

@@ -1,118 +1,118 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe(): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe(): R|kotlin/Unit| {
         receive#(functionWithLazyBody#())
     }
-    public? final? [RAW_FIR] fun receive([RAW_FIR] value: String): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun receive([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun functionWithLazyBody(): <implicit> { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [CONTRACTS] fun receive([CONTRACTS] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] topLevelFunctionsWithImplicitType.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {
         R|/receive|(R|/functionWithLazyBody|())
     }
-    public final [BODY_RESOLVE] fun receive([BODY_RESOLVE] value: R|kotlin/String|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun receive([ResolvedTo(BODY_RESOLVE)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [BODY_RESOLVE] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }

analysis/low-level-api-fir/testdata/lazyResolve/typeAliases/typeAliasWithTypeParameters.txt

@@ -1,70 +1,70 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [RAW_FIR] typealias ResolveMe<[RAW_FIR] T : Int, [RAW_FIR] K> = Map<T, K>
+FILE: [ResolvedTo(RAW_FIR)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(RAW_FIR)] typealias ResolveMe<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> = Map<T, K>
 
 IMPORTS:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [RAW_FIR] typealias ResolveMe<[RAW_FIR] T : Int, [RAW_FIR] K> = Map<T, K>
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(RAW_FIR)] typealias ResolveMe<[ResolvedTo(RAW_FIR)] T : Int, [ResolvedTo(RAW_FIR)] K> = Map<T, K>
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [COMPILER_REQUIRED_ANNOTATIONS] typealias ResolveMe<[COMPILER_REQUIRED_ANNOTATIONS] T : Int, [COMPILER_REQUIRED_ANNOTATIONS] K> = Map<T, K>
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] typealias ResolveMe<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T : Int, [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] K> = Map<T, K>
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [COMPANION_GENERATION] typealias ResolveMe<[COMPANION_GENERATION] T : Int, [COMPANION_GENERATION] K> = Map<T, K>
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(COMPANION_GENERATION)] typealias ResolveMe<[ResolvedTo(COMPANION_GENERATION)] T : Int, [ResolvedTo(COMPANION_GENERATION)] K> = Map<T, K>
 
 SUPER_TYPES:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [SUPER_TYPES] typealias ResolveMe<[SUPER_TYPES] T : Int, [SUPER_TYPES] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(SUPER_TYPES)] typealias ResolveMe<[ResolvedTo(SUPER_TYPES)] T : Int, [ResolvedTo(SUPER_TYPES)] K> = R|kotlin/collections/Map<T, K>|
 
 TYPES:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public? final [TYPES] typealias ResolveMe<[TYPES] T : R|kotlin/Int|, [TYPES] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final [ResolvedTo(TYPES)] typealias ResolveMe<[ResolvedTo(TYPES)] T : R|kotlin/Int|, [ResolvedTo(TYPES)] K> = R|kotlin/collections/Map<T, K>|
 
 STATUS:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] typealias ResolveMe<[STATUS] T : R|kotlin/Int|, [STATUS] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] typealias ResolveMe<[ResolvedTo(STATUS)] T : R|kotlin/Int|, [ResolvedTo(STATUS)] K> = R|kotlin/collections/Map<T, K>|
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] typealias ResolveMe<[EXPECT_ACTUAL_MATCHING] T : R|kotlin/Int|, [EXPECT_ACTUAL_MATCHING] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] typealias ResolveMe<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T : R|kotlin/Int|, [ResolvedTo(EXPECT_ACTUAL_MATCHING)] K> = R|kotlin/collections/Map<T, K>|
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] typealias ResolveMe<[ARGUMENTS_OF_ANNOTATIONS] T : R|kotlin/Int|, [ARGUMENTS_OF_ANNOTATIONS] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] typealias ResolveMe<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T : R|kotlin/Int|, [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] K> = R|kotlin/collections/Map<T, K>|
 
 CONTRACTS:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] typealias ResolveMe<[CONTRACTS] T : R|kotlin/Int|, [CONTRACTS] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] typealias ResolveMe<[ResolvedTo(CONTRACTS)] T : R|kotlin/Int|, [ResolvedTo(CONTRACTS)] K> = R|kotlin/collections/Map<T, K>|
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] typealias ResolveMe<[IMPLICIT_TYPES_BODY_RESOLVE] T : R|kotlin/Int|, [IMPLICIT_TYPES_BODY_RESOLVE] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] typealias ResolveMe<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] K> = R|kotlin/collections/Map<T, K>|
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] typealias ResolveMe<[ANNOTATIONS_ARGUMENTS_MAPPING] T : R|kotlin/Int|, [ANNOTATIONS_ARGUMENTS_MAPPING] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] typealias ResolveMe<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T : R|kotlin/Int|, [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] K> = R|kotlin/collections/Map<T, K>|
 
 BODY_RESOLVE:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] typealias ResolveMe<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] typealias ResolveMe<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> = R|kotlin/collections/Map<T, K>|
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] typeAliasWithTypeParameters.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] typealias ResolveMe<[BODY_RESOLVE] T : R|kotlin/Int|, [BODY_RESOLVE] K> = R|kotlin/collections/Map<T, K>|
+FILE: [ResolvedTo(IMPORTS)] typeAliasWithTypeParameters.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] typealias ResolveMe<[ResolvedTo(BODY_RESOLVE)] T : R|kotlin/Int|, [ResolvedTo(BODY_RESOLVE)] K> = R|kotlin/collections/Map<T, K>|

analysis/low-level-api-fir/testdata/lazyResolve/typeParameterBounds.txt

@@ -1,158 +1,158 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe([RAW_FIR] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(RAW_FIR)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe([ResolvedTo(RAW_FIR)] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun resolveMe([RAW_FIR] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun resolveMe([ResolvedTo(RAW_FIR)] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun resolveMe([COMPILER_REQUIRED_ANNOTATIONS] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun resolveMe([ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun resolveMe([COMPANION_GENERATION] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun resolveMe([ResolvedTo(COMPANION_GENERATION)] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun resolveMe([SUPER_TYPES] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun resolveMe([ResolvedTo(SUPER_TYPES)] foo: Foo): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun resolveMe([TYPES] foo: R|Foo|): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun resolveMe([ResolvedTo(TYPES)] foo: R|Foo|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun resolveMe([STATUS] foo: R|Foo|): R|kotlin/Unit| { LAZY_BLOCK }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun resolveMe([ResolvedTo(STATUS)] foo: R|Foo|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun resolveMe([EXPECT_ACTUAL_MATCHING] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun resolveMe([ResolvedTo(EXPECT_ACTUAL_MATCHING)] foo: R|Foo|): R|kotlin/Unit| {
         foo#.util#()
     }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun resolveMe([ARGUMENTS_OF_ANNOTATIONS] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun resolveMe([ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] foo: R|Foo|): R|kotlin/Unit| {
         foo#.util#()
     }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 CONTRACTS:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun resolveMe([CONTRACTS] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun resolveMe([ResolvedTo(CONTRACTS)] foo: R|Foo|): R|kotlin/Unit| {
         foo#.util#()
     }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun resolveMe([IMPLICIT_TYPES_BODY_RESOLVE] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun resolveMe([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] foo: R|Foo|): R|kotlin/Unit| {
         foo#.util#()
     }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun resolveMe([ANNOTATIONS_ARGUMENTS_MAPPING] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun resolveMe([ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] foo: R|Foo|): R|kotlin/Unit| {
         foo#.util#()
     }
-    public? final? [RAW_FIR] interface Foo : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] interface Bar<[RAW_FIR] T : Foo> : R|kotlin/Any| {
+    public? final? [ResolvedTo(RAW_FIR)] interface Bar<[ResolvedTo(RAW_FIR)] T : Foo> : R|kotlin/Any| {
     }
-    public? final? [RAW_FIR] fun <[RAW_FIR] F : Foo, [RAW_FIR] B : Bar<F>> F.util(): B { LAZY_BLOCK }
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] F : Foo, [ResolvedTo(RAW_FIR)] B : Bar<F>> F.util(): B { LAZY_BLOCK }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun resolveMe([BODY_RESOLVE] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe([ResolvedTo(BODY_RESOLVE)] foo: R|Foo|): R|kotlin/Unit| {
         R|<local>/foo|.R|/util|<R|Foo|, R|Bar<Foo>|>()
     }
-    public abstract [STATUS] interface Foo : R|kotlin/Any| {
+    public abstract [ResolvedTo(STATUS)] interface Foo : R|kotlin/Any| {
     }
-    public? final? [TYPES] interface Bar<[TYPES] T : R|Foo|> : R|kotlin/Any| {
+    public? final? [ResolvedTo(TYPES)] interface Bar<[ResolvedTo(TYPES)] T : R|Foo|> : R|kotlin/Any| {
     }
-    public final [CONTRACTS] fun <[CONTRACTS] F : R|Foo|, [CONTRACTS] B : R|Bar<F>|> R|F|.util(): R|B| {
+    public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] F : R|Foo|, [ResolvedTo(CONTRACTS)] B : R|Bar<F>|> R|F|.util(): R|B| {
         ^util Null(null)!!
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] typeParameterBounds.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun resolveMe([BODY_RESOLVE] foo: R|Foo|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterBounds.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe([ResolvedTo(BODY_RESOLVE)] foo: R|Foo|): R|kotlin/Unit| {
         R|<local>/foo|.R|/util|<R|Foo|, R|Bar<Foo>|>()
     }
-    public abstract [BODY_RESOLVE] interface Foo : R|kotlin/Any| {
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Foo : R|kotlin/Any| {
     }
-    public abstract [BODY_RESOLVE] interface Bar<[BODY_RESOLVE] T : R|Foo|> : R|kotlin/Any| {
+    public abstract [ResolvedTo(BODY_RESOLVE)] interface Bar<[ResolvedTo(BODY_RESOLVE)] T : R|Foo|> : R|kotlin/Any| {
     }
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] F : R|Foo|, [BODY_RESOLVE] B : R|Bar<F>|> R|F|.util(): R|B| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] F : R|Foo|, [ResolvedTo(BODY_RESOLVE)] B : R|Bar<F>|> R|F|.util(): R|B| {
         ^util Null(null)!!
     }

analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfNonLocalFunction.txt

@@ -1,175 +1,175 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(RAW_FIR)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] fun <[RAW_FIR] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 IMPORTS:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [RAW_FIR] fun <[RAW_FIR] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun <[COMPILER_REQUIRED_ANNOTATIONS] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun <[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [COMPANION_GENERATION] fun <[COMPANION_GENERATION] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(COMPANION_GENERATION)] fun <[ResolvedTo(COMPANION_GENERATION)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 SUPER_TYPES:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] class X : R|kotlin/Any| {
-        public? [RAW_FIR] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [SUPER_TYPES] fun <[SUPER_TYPES] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(SUPER_TYPES)] fun <[ResolvedTo(SUPER_TYPES)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 TYPES:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] class X : R|kotlin/Any| {
-        public? [SUPER_TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public? [ResolvedTo(SUPER_TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public? final? [TYPES] fun <[TYPES] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public? final? [ResolvedTo(TYPES)] fun <[ResolvedTo(TYPES)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 STATUS:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class X : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [STATUS] fun <[STATUS] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+        public final [ResolvedTo(STATUS)] fun <[ResolvedTo(STATUS)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
     }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [SUPER_TYPES] class X : R|kotlin/Any| {
-        public [TYPES] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(SUPER_TYPES)] class X : R|kotlin/Any| {
+        public [ResolvedTo(TYPES)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [EXPECT_ACTUAL_MATCHING] fun <[EXPECT_ACTUAL_MATCHING] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun <[ResolvedTo(EXPECT_ACTUAL_MATCHING)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ARGUMENTS_OF_ANNOTATIONS] fun <[ARGUMENTS_OF_ANNOTATIONS] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun <[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 CONTRACTS:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [CONTRACTS] fun <[CONTRACTS] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [IMPLICIT_TYPES_BODY_RESOLVE] fun <[IMPLICIT_TYPES_BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun <[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun <[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] class X : R|kotlin/Any| {
-        public [STATUS] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class X : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=X] constructor(): R|X| {
             LAZY_super<R|kotlin/Any|>
         }
 
-        public final [BODY_RESOLVE] fun <[BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] typeParameterOfNonLocalFunction.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] class X : R|kotlin/Any| {
-        public [BODY_RESOLVE] [ContainingClassKey=X] constructor(): R|X| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfNonLocalFunction.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class X : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=X] constructor(): R|X| {
             super<R|kotlin/Any|>()
         }
 
-        public final [BODY_RESOLVE] fun <[BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+        public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
         }
 
     }

analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopFunction.txt

@@ -1,77 +1,77 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun <[RAW_FIR] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] fun <[RAW_FIR] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] fun <[COMPILER_REQUIRED_ANNOTATIONS] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun <[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] fun <[COMPANION_GENERATION] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun <[ResolvedTo(COMPANION_GENERATION)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] fun <[SUPER_TYPES] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun <[ResolvedTo(SUPER_TYPES)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] fun <[TYPES] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun <[ResolvedTo(TYPES)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] fun <[STATUS] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun <[ResolvedTo(STATUS)] resolveMe> ddd(): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] fun <[EXPECT_ACTUAL_MATCHING] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun <[ResolvedTo(EXPECT_ACTUAL_MATCHING)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] fun <[ARGUMENTS_OF_ANNOTATIONS] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun <[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 CONTRACTS:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] fun <[CONTRACTS] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] fun <[IMPLICIT_TYPES_BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun <[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] fun <[ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun <[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
     }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] typeParameterOfTopFunction.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] fun <[BODY_RESOLVE] resolveMe> ddd(): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopFunction.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] resolveMe> ddd(): R|kotlin/Unit| {
     }

analysis/low-level-api-fir/testdata/lazyResolve/typeParameterOfTopSetter.txt

@@ -1,112 +1,112 @@
 
 RAW_FIR:
-FILE: [RAW_FIR] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] var x: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
-        public? [RAW_FIR] set([RAW_FIR] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(RAW_FIR)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] var x: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 IMPORTS:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [RAW_FIR] var x: Int = LAZY_EXPRESSION
-        public? [RAW_FIR] get(): Int
-        public? [RAW_FIR] set([RAW_FIR] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] var x: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(RAW_FIR)] get(): Int
+        public? [ResolvedTo(RAW_FIR)] set([ResolvedTo(RAW_FIR)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPILER_REQUIRED_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPILER_REQUIRED_ANNOTATIONS] var x: Int = LAZY_EXPRESSION
-        public? [COMPILER_REQUIRED_ANNOTATIONS] get(): Int
-        public? [COMPILER_REQUIRED_ANNOTATIONS] set([COMPILER_REQUIRED_ANNOTATIONS] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] var x: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): Int
+        public? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] set([ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 COMPANION_GENERATION:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [COMPANION_GENERATION] var x: Int = LAZY_EXPRESSION
-        public? [COMPANION_GENERATION] get(): Int
-        public? [COMPANION_GENERATION] set([COMPANION_GENERATION] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] var x: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(COMPANION_GENERATION)] get(): Int
+        public? [ResolvedTo(COMPANION_GENERATION)] set([ResolvedTo(COMPANION_GENERATION)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 SUPER_TYPES:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [SUPER_TYPES] var x: Int = LAZY_EXPRESSION
-        public? [SUPER_TYPES] get(): Int
-        public? [SUPER_TYPES] set([SUPER_TYPES] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] var x: Int = LAZY_EXPRESSION
+        public? [ResolvedTo(SUPER_TYPES)] get(): Int
+        public? [ResolvedTo(SUPER_TYPES)] set([ResolvedTo(SUPER_TYPES)] resolveMe: Int): R|kotlin/Unit| { LAZY_BLOCK }
 
 TYPES:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public? final? [TYPES] var x: R|kotlin/Int| = LAZY_EXPRESSION
-        public? [TYPES] get(): R|kotlin/Int|
-        public? [TYPES] set([TYPES] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] var x: R|kotlin/Int| = LAZY_EXPRESSION
+        public? [ResolvedTo(TYPES)] get(): R|kotlin/Int|
+        public? [ResolvedTo(TYPES)] set([ResolvedTo(TYPES)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
 
 STATUS:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [STATUS] var x: R|kotlin/Int| = LAZY_EXPRESSION
-        public [STATUS] get(): R|kotlin/Int|
-        public [STATUS] set([STATUS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] var x: R|kotlin/Int| = LAZY_EXPRESSION
+        public [ResolvedTo(STATUS)] get(): R|kotlin/Int|
+        public [ResolvedTo(STATUS)] set([ResolvedTo(STATUS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| { LAZY_BLOCK }
 
 EXPECT_ACTUAL_MATCHING:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [EXPECT_ACTUAL_MATCHING] var x: R|kotlin/Int| = IntegerLiteral(2)
-        public [EXPECT_ACTUAL_MATCHING] get(): R|kotlin/Int|
-        public [EXPECT_ACTUAL_MATCHING] set([EXPECT_ACTUAL_MATCHING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] var x: R|kotlin/Int| = IntegerLiteral(2)
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): R|kotlin/Int|
+        public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] set([ResolvedTo(EXPECT_ACTUAL_MATCHING)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Unit#
         }
 
 ARGUMENTS_OF_ANNOTATIONS:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [ARGUMENTS_OF_ANNOTATIONS] var x: R|kotlin/Int| = IntegerLiteral(2)
-        public [ARGUMENTS_OF_ANNOTATIONS] get(): R|kotlin/Int|
-        public [ARGUMENTS_OF_ANNOTATIONS] set([ARGUMENTS_OF_ANNOTATIONS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] var x: R|kotlin/Int| = IntegerLiteral(2)
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): R|kotlin/Int|
+        public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] set([ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Unit#
         }
 
 CONTRACTS:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [CONTRACTS] var x: R|kotlin/Int| = IntegerLiteral(2)
-        public [CONTRACTS] get(): R|kotlin/Int|
-        public [CONTRACTS] set([CONTRACTS] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] var x: R|kotlin/Int| = IntegerLiteral(2)
+        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/Int|
+        public [ResolvedTo(CONTRACTS)] set([ResolvedTo(CONTRACTS)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Unit#
         }
 
 IMPLICIT_TYPES_BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [IMPLICIT_TYPES_BODY_RESOLVE] var x: R|kotlin/Int| = IntegerLiteral(2)
-        public [IMPLICIT_TYPES_BODY_RESOLVE] get(): R|kotlin/Int|
-        public [IMPLICIT_TYPES_BODY_RESOLVE] set([IMPLICIT_TYPES_BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] var x: R|kotlin/Int| = IntegerLiteral(2)
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/Int|
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] set([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Unit#
         }
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [ANNOTATIONS_ARGUMENTS_MAPPING] var x: R|kotlin/Int| = IntegerLiteral(2)
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] get(): R|kotlin/Int|
-        public [ANNOTATIONS_ARGUMENTS_MAPPING] set([ANNOTATIONS_ARGUMENTS_MAPPING] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] var x: R|kotlin/Int| = IntegerLiteral(2)
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): R|kotlin/Int|
+        public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] set([ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Unit#
         }
 
 BODY_RESOLVE:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [RAW_FIR] annotations container
-    public final [BODY_RESOLVE] var x: R|kotlin/Int| = Int(2)
-        public [BODY_RESOLVE] get(): R|kotlin/Int|
-        public [BODY_RESOLVE] set([BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] var x: R|kotlin/Int| = Int(2)
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Q|kotlin/Unit|
         }
 
 FILE RAW TO BODY:
-FILE: [IMPORTS] typeParameterOfTopSetter.kt
-    [BODY_RESOLVE] annotations container
-    public final [BODY_RESOLVE] var x: R|kotlin/Int| = Int(2)
-        public [BODY_RESOLVE] get(): R|kotlin/Int|
-        public [BODY_RESOLVE] set([BODY_RESOLVE] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
+FILE: [ResolvedTo(IMPORTS)] typeParameterOfTopSetter.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] var x: R|kotlin/Int| = Int(2)
+        public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
+        public [ResolvedTo(BODY_RESOLVE)] set([ResolvedTo(BODY_RESOLVE)] resolveMe: R|kotlin/Int|): R|kotlin/Unit| {
             ^ Q|kotlin/Unit|
         }

analysis/low-level-api-fir/testdata/onAirResolve/classInClass.txt

@@ -1,9 +1,9 @@
-public final inner [BODY_RESOLVE] class ONAIR<[STATUS] T> : R|X.BASE| {
-    public [BODY_RESOLVE] X<T>.constructor(): R|X.ONAIR<T>| {
+public final inner [ResolvedTo(BODY_RESOLVE)] class ONAIR<[ResolvedTo(STATUS)] T> : R|X.BASE| {
+    public [ResolvedTo(BODY_RESOLVE)] X<T>.constructor(): R|X.ONAIR<T>| {
         super<R|X.BASE|>()
     }
 
-    public final [BODY_RESOLVE] fun x(): R|X.Y<T>| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun x(): R|X.Y<T>| {
         ^x R|SubstitutionOverride</X.Y.Y>|<R|T|>()
     }
 

analysis/low-level-api-fir/testdata/onAirResolve/enumValueMember.txt

@@ -1,3 +1,3 @@
-public final [BODY_RESOLVE] fun box(): R|kotlin/Int| {
+public final [ResolvedTo(BODY_RESOLVE)] fun box(): R|kotlin/Int| {
     ^box Int(0)
 }

analysis/low-level-api-fir/testdata/onAirResolve/identifierInContext.txt

@@ -1 +1 @@
-[BODY_RESOLVE] lval y: R|kotlin/Int| = R|<local>/f|
+[ResolvedTo(BODY_RESOLVE)] lval y: R|kotlin/Int| = R|<local>/f|

analysis/low-level-api-fir/testdata/onAirResolve/inParameter.txt

@@ -1 +1 @@
-[BODY_RESOLVE] y: R|X.Y|
+[ResolvedTo(BODY_RESOLVE)] y: R|X.Y|

analysis/low-level-api-fir/testdata/onAirResolve/incompleteIdentifier.txt

@@ -1,2 +1,2 @@
-public final [BODY_RESOLVE] val b: R|A.B|
-    public [BODY_RESOLVE] get(): R|A.B|
+public final [ResolvedTo(BODY_RESOLVE)] val b: R|A.B|
+    public [ResolvedTo(BODY_RESOLVE)] get(): R|A.B|

analysis/low-level-api-fir/testdata/onAirResolve/localClass.txt

@@ -1,9 +1,9 @@
-public final [BODY_RESOLVE] class E : R|kotlin/Any| {
-    public [BODY_RESOLVE] constructor(): R|E| {
+public final [ResolvedTo(BODY_RESOLVE)] class E : R|kotlin/Any| {
+    public [ResolvedTo(BODY_RESOLVE)] constructor(): R|E| {
         super<R|kotlin/Any|>()
     }
 
-    public final [BODY_RESOLVE] fun e(): R|kotlin/Int| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun e(): R|kotlin/Int| {
         ^e R|<local>/x|
     }
 

analysis/low-level-api-fir/testdata/onAirResolve/localFunction.txt

@@ -1,3 +1,3 @@
-local final [BODY_RESOLVE] fun x(): R|kotlin/Int| {
+local final [ResolvedTo(BODY_RESOLVE)] fun x(): R|kotlin/Int| {
     ^x R|<local>/x|
 }

analysis/low-level-api-fir/testdata/onAirResolve/loopConstruction.txt

@@ -1,9 +1,9 @@
 while(CMP(<, R|<local>/x|.R|kotlin/Int.compareTo|(Int(2)))) {
      {
-        [BODY_RESOLVE] lval <unary>: R|kotlin/Int| = R|<local>/x|
+        [ResolvedTo(BODY_RESOLVE)] lval <unary>: R|kotlin/Int| = R|<local>/x|
         R|<local>/x| = R|<local>/<unary>|.R|kotlin/Int.dec|()
         R|<local>/<unary>|
     }
 
-    [BODY_RESOLVE] lval z: R|kotlin/Int| = R|<local>/y|
+    [ResolvedTo(BODY_RESOLVE)] lval z: R|kotlin/Int| = R|<local>/y|
 }

analysis/low-level-api-fir/testdata/onAirResolve/memberInClass.txt

@@ -1,3 +1,3 @@
-public final [BODY_RESOLVE] fun <[BODY_RESOLVE] K> niewbe([BODY_RESOLVE] a: R|kotlin/Char|, [BODY_RESOLVE] b: R|kotlin/Double|): R|kotlin/String| {
+public final [ResolvedTo(BODY_RESOLVE)] fun <[ResolvedTo(BODY_RESOLVE)] K> niewbe([ResolvedTo(BODY_RESOLVE)] a: R|kotlin/Char|, [ResolvedTo(BODY_RESOLVE)] b: R|kotlin/Double|): R|kotlin/String| {
     ^niewbe String(Trololo)
 }

analysis/low-level-api-fir/testdata/onAirResolve/memberPropertyInClass.txt

@@ -1,2 +1,2 @@
-public final [BODY_RESOLVE] val niewbe: R|kotlin/String| = String(Hello)
-    public [BODY_RESOLVE] get(): R|kotlin/String|
+public final [ResolvedTo(BODY_RESOLVE)] val niewbe: R|kotlin/String| = String(Hello)
+    public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/String|

analysis/low-level-api-fir/testdata/onAirResolve/memberWithOverride.txt

@@ -1,3 +1,3 @@
-public open override [BODY_RESOLVE] fun baseMember(): R|kotlin/Int| {
+public open override [ResolvedTo(BODY_RESOLVE)] fun baseMember(): R|kotlin/Int| {
     ^baseMember Int(3)
 }

analysis/low-level-api-fir/testdata/onAirResolve/onAirTypesResolve.txt

@@ -1,23 +1,23 @@
-public final [BODY_RESOLVE] class Y : R|kotlin/Any| {
-    public [BODY_RESOLVE] constructor(): R|X.Y| {
+public final [ResolvedTo(BODY_RESOLVE)] class Y : R|kotlin/Any| {
+    public [ResolvedTo(BODY_RESOLVE)] constructor(): R|X.Y| {
         super<R|kotlin/Any|>()
     }
 
-    public open [BODY_RESOLVE] class BASE : R|X| {
-        public [BODY_RESOLVE] constructor(): R|X.Y.BASE| {
+    public open [ResolvedTo(BODY_RESOLVE)] class BASE : R|X| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|X.Y.BASE| {
             super<R|X|>()
         }
 
     }
 
-    public final [BODY_RESOLVE] class DERIVED : R|X.Y.BASE| {
-        public [BODY_RESOLVE] constructor(): R|X.Y.DERIVED| {
+    public final [ResolvedTo(BODY_RESOLVE)] class DERIVED : R|X.Y.BASE| {
+        public [ResolvedTo(BODY_RESOLVE)] constructor(): R|X.Y.DERIVED| {
             super<R|X.Y.BASE|>()
         }
 
     }
 
-    public final [BODY_RESOLVE] fun withType([BODY_RESOLVE] arg: R|X.Y.BASE|): R|kotlin/Unit| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun withType([ResolvedTo(BODY_RESOLVE)] arg: R|X.Y.BASE|): R|kotlin/Unit| {
     }
 
 }

analysis/low-level-api-fir/testdata/onAirResolve/replacementInHeader.txt

@@ -1 +1 @@
-[BODY_RESOLVE] b: R|T|
+[ResolvedTo(BODY_RESOLVE)] b: R|T|

analysis/low-level-api-fir/testdata/onAirResolve/replacementInsidePropertyBody.txt

@@ -1 +1 @@
-[BODY_RESOLVE] lval z: R|kotlin/String| = R|<local>/qqq|
+[ResolvedTo(BODY_RESOLVE)] lval z: R|kotlin/String| = R|<local>/qqq|

analysis/low-level-api-fir/testdata/onAirResolve/replacementInsidePropertyBody2.txt

@@ -1 +1 @@
-[BODY_RESOLVE] lval inSetter: R|kotlin/Int| = R|<local>/value|
+[ResolvedTo(BODY_RESOLVE)] lval inSetter: R|kotlin/Int| = R|<local>/value|

analysis/low-level-api-fir/testdata/onAirResolve/topLevelFunction.txt

@@ -1,5 +1,5 @@
-public final [BODY_RESOLVE] fun onAir(): R|kotlin/Int| {
-    local final [BODY_RESOLVE] fun yyy(): R|kotlin/String| {
+public final [ResolvedTo(BODY_RESOLVE)] fun onAir(): R|kotlin/Int| {
+    local final [ResolvedTo(BODY_RESOLVE)] fun yyy(): R|kotlin/String| {
         ^yyy String(hello)
     }
 

analysis/low-level-api-fir/testdata/onAirResolve/typeAlias.txt

@@ -1 +1 @@
-public final [BODY_RESOLVE] typealias B = R|kotlin/collections/Set<K>|
+public final [ResolvedTo(BODY_RESOLVE)] typealias B = R|kotlin/collections/Set<K>|

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOuterClassArgumentsRequiredChecker.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.extractArgumentsTypeRefAndSource
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.isValidTypeParameterFromOuterDeclaration
@@ -20,9 +21,10 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 
 object FirOuterClassArgumentsRequiredChecker : FirRegularClassChecker() {
+    @OptIn(ResolveStateAccess::class)
     override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
         // Checking the rest super types that weren't resolved on the first OUTER_CLASS_ARGUMENTS_REQUIRED check in FirTypeResolver
-        val oldResolvePhase = declaration.resolvePhase
+        val oldResolveState = declaration.resolveState
         val oldList = declaration.superTypeRefs.toList()
 
         try {
@@ -30,15 +32,15 @@ object FirOuterClassArgumentsRequiredChecker : FirRegularClassChecker() {
                 checkOuterClassArgumentsRequired(superTypeRef, declaration, context, reporter)
             }
         } catch (e: ConcurrentModificationException) {
-            val newResolvePhase = declaration.resolvePhase
+            val newResolveState = declaration.resolveState
             val newList = declaration.superTypeRefs.toList()
 
             throw IllegalStateException(
                 """
                 CME while traversing superTypeRefs of declaration=${declaration.render()}:
                 classId: ${declaration.classId},
-                oldPhase: $oldResolvePhase, oldList: ${oldList.joinToString { it.render() }},
-                newPhase: $newResolvePhase, newList: ${newList.joinToString { it.render() }}
+                oldState: $oldResolveState, oldList: ${oldList.joinToString { it.render() }},
+                newState: $newResolveState, newList: ${newList.joinToString { it.render() }}
                 """.trimIndent(), e
             )
         }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.MutableOrEmptyList
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
-import org.jetbrains.kotlin.fir.caches.firCachesFactory
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
@@ -38,8 +37,7 @@ import kotlin.properties.Delegates
 class FirJavaClass @FirImplementationDetail internal constructor(
     override val source: KtSourceElement?,
     override val moduleData: FirModuleData,
-    @Volatile
-    override var resolvePhase: FirResolvePhase,
+    resolvePhase: FirResolvePhase,
     override val name: Name,
     override val origin: FirDeclarationOrigin.Java,
     private val unEnhancedAnnotations: MutableOrEmptyList<JavaAnnotation>,
@@ -62,6 +60,9 @@ class FirJavaClass @FirImplementationDetail internal constructor(
 
     init {
         symbol.bind(this)
+
+        @OptIn(ResolveStateAccess::class)
+        this.resolveState = resolvePhase.asResolveState()
     }
 
     override val attributes: FirDeclarationAttributes = FirDeclarationAttributes()
@@ -86,10 +87,6 @@ class FirJavaClass @FirImplementationDetail internal constructor(
         error("${::replaceSuperTypeRefs.name} should not be called for ${this::class.simpleName}, ${superTypeRefs::class.simpleName} is lazily calulated")
     }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
     override fun replaceDeprecationsProvider(newDeprecationsProvider: DeprecationsProvider) {
         error("${::replaceDeprecationsProvider.name} should not be called for ${this::class.simpleName}, ${deprecationsProvider::class.simpleName} is lazily calculated")
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -40,8 +40,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
     override val typeParameters: MutableList<FirTypeParameterRef>,
     annotationBuilder: () -> List<FirAnnotation>,
     override var status: FirDeclarationStatus,
-    @Volatile
-    override var resolvePhase: FirResolvePhase,
+    resolvePhase: FirResolvePhase,
     override val dispatchReceiverType: ConeSimpleKotlinType?,
 ) : FirConstructor() {
     override val receiverParameter: FirReceiverParameter? get() = null
@@ -50,6 +49,9 @@ class FirJavaConstructor @FirImplementationDetail constructor(
 
     init {
         symbol.bind(this)
+
+        @OptIn(ResolveStateAccess::class)
+        this.resolveState = resolvePhase.asResolveState()
     }
 
     override val delegatedConstructor: FirDelegatedConstructorCall?
@@ -77,10 +79,6 @@ class FirJavaConstructor @FirImplementationDetail constructor(
         return this
     }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         returnTypeRef.accept(visitor, data)
         controlFlowGraphReference?.accept(visitor, data)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -36,8 +36,7 @@ class FirJavaField @FirImplementationDetail constructor(
     override val origin: FirDeclarationOrigin.Java,
     override val symbol: FirFieldSymbol,
     override val name: Name,
-    @Volatile
-    override var resolvePhase: FirResolvePhase,
+    resolvePhase: FirResolvePhase,
     override var returnTypeRef: FirTypeRef,
     override var status: FirDeclarationStatus,
     override val isVar: Boolean,
@@ -49,6 +48,9 @@ class FirJavaField @FirImplementationDetail constructor(
 ) : FirField() {
     init {
         symbol.bind(this)
+
+        @OptIn(ResolveStateAccess::class)
+        this.resolveState = resolvePhase.asResolveState()
     }
 
     override val receiverParameter: FirReceiverParameter? get() = null
@@ -97,10 +99,6 @@ class FirJavaField @FirImplementationDetail constructor(
         return this
     }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         returnTypeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaMethod.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -49,8 +49,7 @@ class FirJavaMethod @FirImplementationDetail constructor(
     override val source: KtSourceElement?,
     override val moduleData: FirModuleData,
     override val origin: FirDeclarationOrigin.Java,
-    @Volatile
-    override var resolvePhase: FirResolvePhase,
+    resolvePhase: FirResolvePhase,
     override val attributes: FirDeclarationAttributes,
     override var returnTypeRef: FirTypeRef,
     override val typeParameters: MutableList<FirTypeParameter>,
@@ -63,6 +62,9 @@ class FirJavaMethod @FirImplementationDetail constructor(
 ) : FirSimpleFunction() {
     init {
         symbol.bind(this)
+
+        @OptIn(ResolveStateAccess::class)
+        this.resolveState = resolvePhase.asResolveState()
     }
 
     override val receiverParameter: FirReceiverParameter?
@@ -152,10 +154,6 @@ class FirJavaMethod @FirImplementationDetail constructor(
         return this
     }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
     override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef) {
         returnTypeRef = newReturnTypeRef
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaValueParameter.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -33,8 +33,7 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
     override val source: KtSourceElement?,
     override val moduleData: FirModuleData,
     override val origin: FirDeclarationOrigin.Java,
-    @Volatile
-    override var resolvePhase: FirResolvePhase,
+    resolvePhase: FirResolvePhase,
     override val attributes: FirDeclarationAttributes,
     override var returnTypeRef: FirTypeRef,
     override val name: Name,
@@ -46,6 +45,9 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
 ) : FirValueParameter() {
     init {
         symbol.bind(this)
+
+        @OptIn(ResolveStateAccess::class)
+        this.resolveState = resolvePhase.asResolveState()
     }
 
     override val isCrossinline: Boolean
@@ -163,10 +165,6 @@ class FirJavaValueParameter @FirImplementationDetail constructor(
         return this
     }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
-
     override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef) {
         returnTypeRef = newReturnTypeRef
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaAnnotationSyntheticPropertiesScope.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.fir.declarations.resolvePhase
 
 class JavaAnnotationSyntheticPropertiesScope(
     private val session: FirSession,