[LL FIR] add proper lazy resolve support for script dependent declarations

Such declarations (only `ResultProperty` for now) should delegate
resolution to the script, because they depend on its content

^KT-60728

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

@@ -22,11 +22,13 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.diagnostics.ConeDestructuringDeclarationsOnTopLevel
+import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptDependentDeclaration
 
 class FirDesignationWithFile(
     path: List<FirRegularClass>,
@@ -274,6 +276,9 @@ fun FirElementWithResolveState.tryCollectDesignationWithFile(): FirDesignationWi
         }
 
         is FirDeclaration -> {
+            val scriptDesignation = scriptDesignation()
+            if (scriptDesignation != null) return scriptDesignation
+
             val path = collectDesignationPath(this) ?: return null
             val firFile = path.lastOrNull()?.getContainingFile() ?: getContainingFile() ?: return null
             FirDesignationWithFile(path, this, firFile)
@@ -282,3 +287,10 @@ fun FirElementWithResolveState.tryCollectDesignationWithFile(): FirDesignationWi
         else -> unexpectedElementError<FirElementWithResolveState>(this)
     }
 }
+
+private fun FirDeclaration.scriptDesignation(): FirDesignationWithFile? {
+    if (this !is FirStatement || !isScriptDependentDeclaration) return null
+    val firFile = getContainingFile() ?: return null
+    val firScript = firFile.declarations.singleOrNull() as? FirScript ?: return null
+    return FirDesignationWithFile(path = emptyList(), firScript, firFile)
+}

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

@@ -5,11 +5,14 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptDependentDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptStatement
 import org.jetbrains.kotlin.fir.FirElement
 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.expressions.FirStatement
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 internal object LLFirPhaseUpdater {
@@ -61,9 +64,8 @@ internal object LLFirPhaseUpdater {
         }
 
         when (element) {
-            is FirFunction -> {
-                element.valueParameters.forEach { updatePhaseForNonLocals(it, newPhase, isTargetDeclaration = false) }
-            }
+            is FirScript -> element.forEachDependentDeclaration { updatePhaseForNonLocals(it, newPhase, isTargetDeclaration = false) }
+            is FirFunction -> element.valueParameters.forEach { updatePhaseForNonLocals(it, newPhase, isTargetDeclaration = false) }
             is FirProperty -> {
                 element.getter?.let { updatePhaseForNonLocals(it, newPhase, isTargetDeclaration = false) }
                 element.setter?.let { updatePhaseForNonLocals(it, newPhase, isTargetDeclaration = false) }
@@ -77,7 +79,10 @@ internal object LLFirPhaseUpdater {
 private object PhaseUpdatingTransformer : FirVisitor<Unit, FirResolvePhase>() {
     override fun visitElement(element: FirElement, data: FirResolvePhase) {
         if (element is FirElementWithResolveState) {
-            if (element.resolvePhase >= data && element !is FirDefaultPropertyAccessor) return
+            if (element.resolvePhase >= data &&
+                element !is FirDefaultPropertyAccessor &&
+                !(element is FirStatement && element.isScriptDependentDeclaration)
+            ) return
 
             @OptIn(ResolveStateAccess::class)
             element.resolveState = data.asResolveState()

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirReturnTypeCalculatorWithJump
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptStatement
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -73,4 +74,18 @@ internal abstract class LLFirAbstractBodyTargetResolver(
     protected open fun rawResolve(target: FirElementWithResolveState) {
         target.transformSingle(transformer, ResolutionMode.ContextIndependent)
     }
+
+    protected fun resolveScript(script: FirScript) {
+        transformer.declarationsTransformer?.withScript(script) {
+            script.parameters.forEach { it.transformSingle(transformer, ResolutionMode.ContextIndependent) }
+            script.statements.forEach {
+                if (it.isScriptStatement) {
+                    transformer.firResolveContextCollector?.addStatementContext(it, transformer.context)
+                    it.transformSingle(transformer, ResolutionMode.ContextIndependent)
+                }
+            }
+
+            script
+        }
+    }
 }

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

@@ -155,20 +155,9 @@ private class LLFirBodyTargetResolver(
         }
     }
 
-    override fun rawResolve(target: FirElementWithResolveState) {
-        if (target !is FirScript) return super.rawResolve(target)
-
-        transformer.declarationsTransformer.withScript(target) {
-            target.parameters.forEach { it.transformSingle(transformer, ResolutionMode.ContextIndependent) }
-            target.statements.forEach {
-                if (it.isScriptStatement) {
-                    transformer.firResolveContextCollector?.addStatementContext(it, transformer.context)
-                    it.transformSingle(transformer, ResolutionMode.ContextIndependent)
-                }
-            }
-
-            target
-        }
+    override fun rawResolve(target: FirElementWithResolveState) = when (target) {
+        is FirScript -> resolveScript(target)
+        else -> super.rawResolve(target)
     }
 }
 

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

@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompilerRequiredA
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.FirUserTypeRef
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptDependentDeclaration
 
 internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) {
     override fun resolve(
@@ -233,6 +235,8 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver(
                     target.setter?.let(::publishResult)
                     target.backingField?.let(::publishResult)
                 }
+
+                is FirScript -> target.forEachDependentDeclaration(::publishResult)
             }
         }
     }
@@ -255,6 +259,10 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver(
                 setter?.annotationsForTransformationTo(map)
                 backingField?.annotationsForTransformationTo(map)
             }
+
+            is FirScript -> {
+                forEachDependentDeclaration { it.annotationsForTransformationTo(map) }
+            }
         }
 
         if (annotations.isEmpty()) return
@@ -305,6 +313,7 @@ private fun FirAnnotationContainer.hasAnnotationsToResolve(): Boolean {
                 this.setter?.hasAnnotationsToResolve() == true ||
                 this.backingField?.hasAnnotationsToResolve() == true
 
+        is FirScript -> statements.any { it.isScriptDependentDeclaration && it.hasAnnotationsToResolve() }
         else -> false
     }
 }

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptDependentDeclaration
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
 import org.jetbrains.kotlin.fir.FirSession
@@ -69,9 +70,13 @@ internal class LLFirImplicitBodyTargetResolver(
             is FirFunction -> resolve(target, BodyStateKeepers.FUNCTION)
             is FirProperty -> resolve(target, BodyStateKeepers.PROPERTY)
             is FirVariable -> resolve(target, BodyStateKeepers.VARIABLE)
+            is FirScript -> {
+                if (target.statements.any { it.isScriptDependentDeclaration }) {
+                    resolve(target, BodyStateKeepers.SCRIPT)
+                }
+            }
             is FirRegularClass,
             is FirTypeAlias,
-            is FirScript,
             is FirAnonymousInitializer,
             is FirDanglingModifierList,
             is FirFileAnnotationsContainer,
@@ -82,12 +87,13 @@ internal class LLFirImplicitBodyTargetResolver(
         }
     }
 
-    override fun rawResolve(target: FirElementWithResolveState) {
-        if (target is FirCallableDeclaration && target.attributes.fakeOverrideSubstitution != null) {
+    override fun rawResolve(target: FirElementWithResolveState): Unit = when {
+        target is FirScript -> resolveScript(target)
+        target is FirCallableDeclaration && target.attributes.fakeOverrideSubstitution != null -> {
             transformer.returnTypeCalculator.fakeOverrideTypeCalculator.computeReturnType(target)
-            return
+            Unit
         }
 
-        super.rawResolve(target)
+        else -> super.rawResolve(target)
     }
 }

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -58,6 +59,7 @@ internal abstract class LLFirLazyResolver(
         checkPropertyAccessorsAreResolved(target)
         checkPropertyBackingFieldIsResolved(target)
         checkTypeParametersAreResolved(target)
+        checkScriptDependentDeclaration(target)
     }
 
     private fun checkPropertyAccessorsAreResolved(declaration: FirDeclaration) {
@@ -92,4 +94,9 @@ internal abstract class LLFirLazyResolver(
             }
         }
     }
+
+    private fun checkScriptDependentDeclaration(declaration: FirDeclaration) {
+        if (declaration !is FirScript) return
+        declaration.forEachDependentDeclaration(::checkIsResolved)
+    }
 }

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarg
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeclarationStatusIsResolved
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -166,13 +167,10 @@ private class LLFirStatusTargetResolver(
 
     override fun doLazyResolveUnderLock(target: FirElementWithResolveState) {
         when (target) {
-            is FirRegularClass -> {
-                error("should be resolved in doResolveWithoutLock")
-            }
-            is FirScript -> {}
-            else -> {
-                target.transformSingle(transformer, data = null)
-            }
+            is FirRegularClass -> error("should be resolved in doResolveWithoutLock")
+            // It is fine to call status transformer under lock, because declarations can't have a containing class
+            is FirScript -> target.forEachDependentDeclaration { it.transformSingle(transformer, data = null) }
+            else -> target.transformSingle(transformer, data = null)
         }
     }
 

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReceiverTypeRef
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
@@ -138,6 +139,7 @@ private class LLFirTypeTargetResolver(
     private fun resolveScriptTypes(firScript: FirScript) {
         firScript.annotations.forEach { it.accept(transformer, null) }
         firScript.contextReceivers.forEach { it.accept(transformer, null) }
+        firScript.forEachDependentDeclaration { it.accept(transformer, null) }
     }
 
     private fun resolveClassTypes(firClass: FirRegularClass) {

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

@@ -220,4 +220,14 @@ internal inline fun FirDeclaration.forEachDeclaration(action: (FirDeclaration) -
     }
 }
 
-internal val FirStatement.isScriptStatement: Boolean get() = this !is FirDeclaration || origin is FirDeclarationOrigin.ScriptCustomization
+internal val FirStatement.isScriptStatement: Boolean get() = this !is FirDeclaration || isScriptDependentDeclaration
+
+internal val FirStatement.isScriptDependentDeclaration: Boolean
+    get() = this is FirDeclaration && origin == FirDeclarationOrigin.ScriptCustomization.ResultProperty
+
+internal inline fun FirScript.forEachDependentDeclaration(action: (FirDeclaration) -> Unit) {
+    for (statement in statements) {
+        if (statement !is FirDeclaration || !statement.isScriptDependentDeclaration) continue
+        action(statement)
+    }
+}

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

@@ -87,8 +87,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): <implicit>
 
 
 COMPANION_GENERATION:
@@ -118,8 +118,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(COMPANION_GENERATION)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(COMPANION_GENERATION)] get(): <implicit>
 
 
 SUPER_TYPES:
@@ -149,8 +149,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(SUPER_TYPES)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(SUPER_TYPES)] get(): <implicit>
 
 
 TYPES:
@@ -180,8 +180,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(TYPES)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(TYPES)] get(): <implicit>
 
 
 STATUS:
@@ -211,8 +211,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(STATUS)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(STATUS)] get(): <implicit>
 
 
 EXPECT_ACTUAL_MATCHING:
@@ -242,8 +242,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): <implicit>
 
 
 ARGUMENTS_OF_ANNOTATIONS:
@@ -273,8 +273,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): <implicit>
 
 
 CONTRACTS:
@@ -304,8 +304,8 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
         )
             public? [ResolvedTo(RAW_FIR)] get(): <implicit>
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(CONTRACTS)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
+            public [ResolvedTo(CONTRACTS)] get(): <implicit>
 
 
 IMPLICIT_TYPES_BODY_RESOLVE:
@@ -314,29 +314,29 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
     SCRIPT: [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] class Builder : R|kotlin/Any| {
-            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] constructor(): R|Builder| {
+        public final [ResolvedTo(STATUS)] class Builder : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Builder] constructor(): R|Builder| {
                 super<R|kotlin/Any|>()
             }
 
-            public? final? [ResolvedTo(RAW_FIR)] var version: String = String()
-                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] get(): String
-                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] set([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit|
+            public final [ResolvedTo(CONTRACTS)] var version: R|kotlin/String| = String()
+                public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Builder] get(): R|kotlin/String|
+                public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Builder] set([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit|
 
         }
 
-        public? final? [ResolvedTo(RAW_FIR)] fun build([ResolvedTo(RAW_FIR)] action: ( Builder.() -> Unit )): <implicit> {
-            ^build Builder#().apply#(action#)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun build([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] action: R|Builder.() -> kotlin/Unit|): R|Builder| {
+            ^build R|/Builder.Builder|().R|kotlin/apply|<R|Builder|>(R|<local>/action|)
         }
 
-        public? final? [ResolvedTo(RAW_FIR)] val builder: <implicit> = build#(<L> = [ResolvedTo(RAW_FIR)] build@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-            version# = String(321)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val builder: R|Builder| = R|/build|(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=@ExtensionFunctionType kotlin/Function1<Builder, kotlin/Unit>] build@fun R|Builder|.<anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+            this@R|special/anonymous|.R|/Builder.version| = String(321)
         }
         )
-            public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|Builder|
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val $$result: <ERROR TYPE REF: Unresolved name: execute> = @R|kotlin/Suppress|[Types](names = vararg(String(abc))) @R|kotlin/Deprecated|[Types](message = String(it is deprecated)) R|/builder|.<Unresolved name: execute>#()
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): <ERROR TYPE REF: Unresolved name: execute>
 
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
@@ -345,29 +345,29 @@ FILE: [ResolvedTo(IMPORTS)] script4.kts
     SCRIPT: [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] class Builder : R|kotlin/Any| {
-            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] constructor(): R|Builder| {
+        public final [ResolvedTo(STATUS)] class Builder : R|kotlin/Any| {
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Builder] constructor(): R|Builder| {
                 super<R|kotlin/Any|>()
             }
 
-            public? final? [ResolvedTo(RAW_FIR)] var version: String = String()
-                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] get(): String
-                public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Builder] set([ResolvedTo(RAW_FIR)] value: String): R|kotlin/Unit|
+            public final [ResolvedTo(CONTRACTS)] var version: R|kotlin/String| = String()
+                public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Builder] get(): R|kotlin/String|
+                public [ResolvedTo(CONTRACTS)] [ContainingClassKey=Builder] set([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit|
 
         }
 
-        public? final? [ResolvedTo(RAW_FIR)] fun build([ResolvedTo(RAW_FIR)] action: ( Builder.() -> Unit )): <implicit> {
-            ^build Builder#().apply#(action#)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun build([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] action: R|Builder.() -> kotlin/Unit|): R|Builder| {
+            ^build R|/Builder.Builder|().R|kotlin/apply|<R|Builder|>(R|<local>/action|)
         }
 
-        public? final? [ResolvedTo(RAW_FIR)] val builder: <implicit> = build#(<L> = [ResolvedTo(RAW_FIR)] build@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-            version# = String(321)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val builder: R|Builder| = R|/build|(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=@ExtensionFunctionType kotlin/Function1<Builder, kotlin/Unit>] build@fun R|Builder|.<anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+            this@R|special/anonymous|.R|/Builder.version| = String(321)
         }
         )
-            public? [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|Builder|
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = @Suppress[Unresolved](String(abc)) @Deprecated[Unresolved](String(it is deprecated)) builder#.execute#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val $$result: <ERROR TYPE REF: Unresolved name: execute> = @R|kotlin/Suppress|[Types](names = vararg(String(abc))) @R|kotlin/Deprecated|[Types](message = String(it is deprecated)) R|/builder|.<Unresolved name: execute>#()
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): <ERROR TYPE REF: Unresolved name: execute>
 
 
 BODY_RESOLVE:

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

@@ -29,155 +29,155 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
 COMPILER_REQUIRED_ANNOTATIONS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): <implicit>
 
 
 COMPANION_GENERATION:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(COMPANION_GENERATION)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(COMPANION_GENERATION)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(COMPANION_GENERATION)] get(): <implicit>
 
 
 SUPER_TYPES:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(SUPER_TYPES)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(SUPER_TYPES)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(SUPER_TYPES)] get(): <implicit>
 
 
 TYPES:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(TYPES)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(TYPES)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(TYPES)] get(): <implicit>
 
 
 STATUS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(STATUS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(STATUS)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(STATUS)] get(): <implicit>
 
 
 EXPECT_ACTUAL_MATCHING:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(EXPECT_ACTUAL_MATCHING)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): <implicit>
 
 
 ARGUMENTS_OF_ANNOTATIONS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): <implicit>
 
 
 CONTRACTS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(CONTRACTS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
             ^foo IntegerLiteral(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(CONTRACTS)] val $$result: <implicit> = foo#()
+            public [ResolvedTo(CONTRACTS)] get(): <implicit>
 
 
 IMPLICIT_TYPES_BODY_RESOLVE:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
-            ^foo IntegerLiteral(24)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Int| {
+            ^foo Int(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val $$result: R|kotlin/Int| = R|/foo|()
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/Int|
 
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
-            ^foo IntegerLiteral(24)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Int| {
+            ^foo Int(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val $$result: R|kotlin/Int| = R|/foo|()
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): R|kotlin/Int|
 
 
 BODY_RESOLVE:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclaration.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
-        [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(BODY_RESOLVE)]
+        [ResolvedTo(BODY_RESOLVE)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun foo(): <implicit> {
-            ^foo IntegerLiteral(24)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun foo(): R|kotlin/Int| {
+            ^foo Int(24)
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#()
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+        public final [ResolvedTo(BODY_RESOLVE)] val $$result: R|kotlin/Int| = R|/foo|()
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Int|
 
 
 FILE RAW TO BODY:

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

@@ -45,14 +45,14 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
 COMPILER_REQUIRED_ANNOTATIONS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -61,20 +61,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] get(): <implicit>
 
 
 COMPANION_GENERATION:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(COMPANION_GENERATION)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(COMPANION_GENERATION)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -83,20 +83,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(COMPANION_GENERATION)] get(): <implicit>
 
 
 SUPER_TYPES:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
     context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    SCRIPT: [ResolvedTo(SUPER_TYPES)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(SUPER_TYPES)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -105,20 +105,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(SUPER_TYPES)] get(): <implicit>
 
 
 TYPES:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(TYPES)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(TYPES)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -127,20 +127,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(TYPES)] get(): <implicit>
 
 
 STATUS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(STATUS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(STATUS)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -149,20 +149,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(STATUS)] get(): <implicit>
 
 
 EXPECT_ACTUAL_MATCHING:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(EXPECT_ACTUAL_MATCHING)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -171,20 +171,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(EXPECT_ACTUAL_MATCHING)] get(): <implicit>
 
 
 ARGUMENTS_OF_ANNOTATIONS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -193,20 +193,20 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] get(): <implicit>
 
 
 CONTRACTS:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(CONTRACTS)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
         public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
+        public final [ResolvedTo(CONTRACTS)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
             println#(String(foo))
             foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
                 [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
@@ -215,73 +215,73 @@ FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(CONTRACTS)] get(): <implicit>
 
 
 IMPLICIT_TYPES_BODY_RESOLVE:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
+        public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] T> foo([ResolvedTo(CONTRACTS)] action: R|() -> T|): R|T| {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-            println#(String(foo))
-            foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-                [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
-                println#(i#)
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val $$result: R|kotlin/Unit| = R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+            R|kotlin/io/println|(String(foo))
+            R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+                [ResolvedTo(RAW_FIR)] lval i: R|kotlin/Int| = Int(1)
+                R|kotlin/io/println|(R|<local>/i|)
             }
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/Unit|
 
 
 ANNOTATIONS_ARGUMENTS_MAPPING:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)]
         [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
+        public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] T> foo([ResolvedTo(CONTRACTS)] action: R|() -> T|): R|T| {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-            println#(String(foo))
-            foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-                [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
-                println#(i#)
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] val $$result: R|kotlin/Unit| = R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+            R|kotlin/io/println|(String(foo))
+            R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(RAW_FIR)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+                [ResolvedTo(RAW_FIR)] lval i: R|kotlin/Int| = Int(1)
+                R|kotlin/io/println|(R|<local>/i|)
             }
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] get(): R|kotlin/Unit|
 
 
 BODY_RESOLVE:
 FILE: [ResolvedTo(IMPORTS)] syntheticResultDeclarationWithBigBody.kts
-    context(<script>@kotlin.script.templates.standard.ScriptTemplateWithArgs)
-    SCRIPT: [ResolvedTo(RAW_FIR)]
-        [ResolvedTo(RAW_FIR)] lval args: R|kotlin/Array<kotlin/String>|
+    context(<script>@R|kotlin/script/templates/standard/ScriptTemplateWithArgs|)
+    SCRIPT: [ResolvedTo(BODY_RESOLVE)]
+        [ResolvedTo(BODY_RESOLVE)] lval args: R|kotlin/Array<kotlin/String>|
 
-        public? final? [ResolvedTo(RAW_FIR)] fun <[ResolvedTo(RAW_FIR)] T> foo([ResolvedTo(RAW_FIR)] action: ( () -> T )): T {
+        public final [ResolvedTo(CONTRACTS)] fun <[ResolvedTo(CONTRACTS)] T> foo([ResolvedTo(CONTRACTS)] action: R|() -> T|): R|T| {
             ^foo action#()
         }
 
-        public final [ResolvedTo(RAW_FIR)] val $$result: <implicit> = foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-            println#(String(foo))
-            foo#(<L> = [ResolvedTo(RAW_FIR)] foo@fun <implicit>.<anonymous>(): <implicit> <inline=Unknown>  {
-                [ResolvedTo(RAW_FIR)] lval i: <implicit> = IntegerLiteral(1)
-                println#(i#)
+        public final [ResolvedTo(BODY_RESOLVE)] val $$result: R|kotlin/Unit| = R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(BODY_RESOLVE)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+            R|kotlin/io/println|(String(foo))
+            R|/foo|<R|kotlin/Unit|>(<L> = [ResolvedTo(BODY_RESOLVE)] [MatchingParameterFunctionTypeKey=kotlin/Function0<T>] foo@fun <anonymous>(): R|kotlin/Unit| <inline=NoInline>  {
+                [ResolvedTo(BODY_RESOLVE)] lval i: R|kotlin/Int| = Int(1)
+                R|kotlin/io/println|(R|<local>/i|)
             }
             )
         }
         )
-            public [ResolvedTo(RAW_FIR)] get(): <implicit>
+            public [ResolvedTo(BODY_RESOLVE)] get(): R|kotlin/Unit|
 
 
 FILE RAW TO BODY: