[LL FIR] implement LLFirReturnTypeCalculatorWithJump

To provide the correct designation and locks strategy

^KT-56550
^KT-58083 Fixed

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

@@ -8,12 +8,18 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirLazyResolveContractChecker
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
+import org.jetbrains.kotlin.fir.FirSession
 
 internal class LLFirGlobalResolveComponents(val project: Project) {
     companion object {
         fun getInstance(project: Project): LLFirGlobalResolveComponents {
             return project.getService(LLFirGlobalResolveComponents::class.java)
         }
+
+        fun getInstance(llFirSession: FirSession): LLFirGlobalResolveComponents {
+            return getInstance((llFirSession as LLFirSession).project)
+        }
     }
 
     val checker: LLFirLazyResolveContractChecker = LLFirLazyResolveContractChecker()

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

@@ -1,24 +1,28 @@
 /*
- * 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.
  */
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir
 
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+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.sessions.LLFirSession
 
 internal object PersistentCheckerContextFactory {
     fun createEmptyPersistenceCheckerContext(sessionHolder: SessionHolder): PersistentCheckerContext {
-        val returnTypeCalculator = createReturnTypeCalculatorForIDE(
-            sessionHolder.scopeSession,
-            ImplicitBodyResolveComputationSession(),
-            ::LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+        val returnTypeCalculator = LLFirReturnTypeCalculatorWithJump(
+            scopeSession = sessionHolder.scopeSession,
+            implicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession(),
+            lockProvider = LLFirGlobalResolveComponents.getInstance(sessionHolder.session).lockProvider,
+            towerDataContextCollector = null,
         )
+
         return PersistentCheckerContext(sessionHolder, returnTypeCalculator)
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt

@@ -1,99 +0,0 @@
-/*
- * Copyright 2010-2020 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.element.builder
-
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.resolve.ResolutionMode
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-
-fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
-    designation: Iterator<FirElement>,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-    returnTypeCalculator: ReturnTypeCalculator,
-    outerBodyResolveContext: BodyResolveContext?,
-): FirDesignatedBodyResolveTransformerForReturnTypeCalculator {
-
-    val designationList = mutableListOf<FirElement>()
-    designation.forEachRemaining(designationList::add)
-    require(designationList.isNotEmpty()) { "Designation should not be empty" }
-
-    return LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
-        designationList,
-        session,
-        scopeSession,
-        implicitBodyResolveComputationSession,
-        returnTypeCalculator,
-        outerBodyResolveContext
-    )
-}
-
-private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
-    private val designation: List<FirElement>,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-    returnTypeCalculator: ReturnTypeCalculator,
-    outerBodyResolveContext: BodyResolveContext?,
-) : FirDesignatedBodyResolveTransformerForReturnTypeCalculator(
-    designation.iterator(),
-    session,
-    scopeSession,
-    implicitBodyResolveComputationSession,
-    returnTypeCalculator,
-    outerBodyResolveContext
-) {
-    private val targetDeclaration = designation.last()
-
-    private inline fun <D : FirCallableDeclaration> D.processCallable(body: (FirDesignation) -> Unit) {
-        if (this !== targetDeclaration) return
-        if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return
-        lazyResolveToPhase(FirResolvePhase.TYPES)
-        if (returnTypeRef is FirImplicitTypeRef) {
-            val declarationList = designation.filterIsInstance<FirDeclaration>()
-            check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" }
-            val designationPath = declarationList.dropLast(1)
-            check(designationPath.all { it is FirRegularClass })
-            @Suppress("UNCHECKED_CAST")
-            body(FirDesignation(designationPath as List<FirRegularClass>, this))
-        }
-    }
-
-    override fun transformSimpleFunction(
-        simpleFunction: FirSimpleFunction,
-        data: ResolutionMode
-    ): FirSimpleFunction {
-        if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) {
-            simpleFunction.processCallable {
-                FirLazyBodiesCalculator.calculateLazyBodiesForFunction(it)
-            }
-        }
-
-        return super.transformSimpleFunction(simpleFunction, data)
-    }
-
-    override fun transformProperty(
-        property: FirProperty,
-        data: ResolutionMode
-    ): FirProperty {
-        property.processCallable {
-            FirLazyBodiesCalculator.calculateLazyBodyForProperty(it)
-        }
-        return super.transformProperty(property, data)
-    }
-}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt

@@ -1,81 +0,0 @@
-/*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder
-
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.resolve.ResolutionMode
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-
-fun LLFirEnsureBasedTransformerForReturnTypeCalculator(
-    designation: Iterator<FirElement>,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-    returnTypeCalculator: ReturnTypeCalculator,
-    outerBodyResolveContext: BodyResolveContext?,
-): FirDesignatedBodyResolveTransformerForReturnTypeCalculator {
-
-    val designationList = mutableListOf<FirElement>()
-    designation.forEachRemaining(designationList::add)
-    require(designationList.isNotEmpty()) { "Designation should not be empty" }
-
-    return LLFirEnsureBasedTransformerForReturnTypeCalculatorImpl(
-        designationList,
-        session,
-        scopeSession,
-        implicitBodyResolveComputationSession,
-        returnTypeCalculator,
-        outerBodyResolveContext
-    )
-}
-
-
-private class LLFirEnsureBasedTransformerForReturnTypeCalculatorImpl(
-    designation: List<FirElement>,
-    session: FirSession,
-    scopeSession: ScopeSession,
-    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-    returnTypeCalculator: ReturnTypeCalculator,
-    outerBodyResolveContext: BodyResolveContext?,
-) : FirDesignatedBodyResolveTransformerForReturnTypeCalculator(
-    designation.iterator(),
-    session,
-    scopeSession,
-    implicitBodyResolveComputationSession,
-    returnTypeCalculator,
-    outerBodyResolveContext
-) {
-    private val targetDeclaration = designation.last()
-
-    private fun <T : FirCallableDeclaration> T.ensureReturnType() {
-        if (this !== targetDeclaration) return
-        if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return
-        lazyResolveToPhase(FirResolvePhase.TYPES)
-        if (returnTypeRef is FirImplicitTypeRef) {
-            lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-        }
-    }
-
-    override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): FirSimpleFunction {
-        simpleFunction.ensureReturnType()
-        return super.transformSimpleFunction(simpleFunction, data)
-    }
-
-
-    override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
-        property.ensureReturnType()
-        return super.transformProperty(property, data)
-    }
-}

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
-import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+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.fir.FirElementWithResolveState
@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE
 
 internal abstract class LLFirAbstractBodyTargetResolver(
     resolveTarget: LLFirResolveTarget,
@@ -28,11 +28,13 @@ internal abstract class LLFirAbstractBodyTargetResolver(
     protected val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession(),
     isJumpingPhase: Boolean = false
 ) : LLFirTargetResolver(resolveTarget, lockProvider, resolvePhase, isJumpingPhase) {
-
-    protected fun createReturnTypeCalculator(): ReturnTypeCalculator = createReturnTypeCalculatorForIDE(
+    protected fun createReturnTypeCalculator(
+        towerDataContextCollector: FirTowerDataContextCollector?,
+    ): ReturnTypeCalculator = LLFirReturnTypeCalculatorWithJump(
         scopeSession,
         implicitBodyResolveComputationSession,
-        ::LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
+        lockProvider,
+        towerDataContextCollector,
     )
 
     abstract val transformer: FirAbstractBodyResolveTransformerDispatcher

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

@@ -67,7 +67,7 @@ private class LLFirAnnotationArgumentsMappingTargetResolver(
         session,
         scopeSession,
         resolverPhase,
-        returnTypeCalculator = createReturnTypeCalculator()
+        returnTypeCalculator = createReturnTypeCalculator(towerDataContextCollector = null)
     )
 
     override fun doLazyResolveUnderLock(target: FirElementWithResolveState) {

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

@@ -78,7 +78,7 @@ private class LLFirAnnotationArgumentsTargetResolver(
         session,
         scopeSession,
         resolverPhase,
-        returnTypeCalculator = createReturnTypeCalculator()
+        returnTypeCalculator = createReturnTypeCalculator(towerDataContextCollector = null)
     )
 
     override fun doLazyResolveUnderLock(target: FirElementWithResolveState) {

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

@@ -74,7 +74,7 @@ private class LLFirBodyTargetResolver(
         phase = resolverPhase,
         implicitTypeOnly = false,
         scopeSession = scopeSession,
-        returnTypeCalculator = createReturnTypeCalculator(),
+        returnTypeCalculator = createReturnTypeCalculator(towerDataContextCollector = towerDataContextCollector),
         firTowerDataContextCollector = towerDataContextCollector,
     ) {
         override val preserveCFGForClasses: Boolean get() = false

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

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitAwareBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 
 internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
@@ -51,27 +52,29 @@ internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePha
     }
 }
 
-private class LLFirImplicitBodyTargetResolver(
+internal class LLFirImplicitBodyTargetResolver(
     target: LLFirResolveTarget,
     lockProvider: LLFirLockProvider,
     session: FirSession,
     scopeSession: ScopeSession,
     towerDataContextCollector: FirTowerDataContextCollector?,
+    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession? = null,
 ) : LLFirAbstractBodyTargetResolver(
     target,
     lockProvider,
     scopeSession,
     FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE,
+    implicitBodyResolveComputationSession = implicitBodyResolveComputationSession ?: ImplicitBodyResolveComputationSession(),
     isJumpingPhase = true,
 ) {
     override val transformer = object : FirImplicitAwareBodyResolveTransformer(
         session,
-        implicitBodyResolveComputationSession = implicitBodyResolveComputationSession,
+        implicitBodyResolveComputationSession = this.implicitBodyResolveComputationSession,
         phase = resolverPhase,
         implicitTypeOnly = true,
         scopeSession = scopeSession,
         firTowerDataContextCollector = towerDataContextCollector,
-        returnTypeCalculator = createReturnTypeCalculator(),
+        returnTypeCalculator = createReturnTypeCalculator(towerDataContextCollector = towerDataContextCollector),
     ) {
         override val preserveCFGForClasses: Boolean get() = false
     }

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

@@ -0,0 +1,53 @@
+/*
+ * 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.element.builder
+
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignationWithFile
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget
+import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplicitBodyTargetResolver
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplicitTypesLazyResolver
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ReturnTypeCalculatorWithJump
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+
+internal class LLFirReturnTypeCalculatorWithJump(
+    scopeSession: ScopeSession,
+    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
+    private val lockProvider: LLFirLockProvider,
+    private val towerDataContextCollector: FirTowerDataContextCollector?,
+) : ReturnTypeCalculatorWithJump(scopeSession, implicitBodyResolveComputationSession) {
+    override fun resolveDeclaration(declaration: FirCallableDeclaration): FirResolvedTypeRef {
+        if (declaration.returnTypeRef !is FirImplicitTypeRef) {
+            return declaration.symbol.resolvedReturnTypeRef
+        }
+
+        declaration.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE.previous)
+
+        val designation = declaration.collectDesignationWithFile().asResolveTarget()
+        val resolver = LLFirImplicitBodyTargetResolver(
+            designation,
+            lockProvider = lockProvider,
+            session = declaration.moduleData.session,
+            scopeSession = scopeSession,
+            towerDataContextCollector = towerDataContextCollector,
+            implicitBodyResolveComputationSession = implicitBodyResolveComputationSession,
+        )
+
+        lockProvider.withGlobalPhaseLock(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
+            resolver.resolveDesignation()
+        }
+
+        LLFirImplicitTypesLazyResolver.checkIsResolved(designation)
+        return declaration.returnTypeRef as FirResolvedTypeRef
+    }
+}

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

@@ -384,7 +384,7 @@ FILE: [ResolvedTo(IMPORTS)] delegates.kt
     }
     public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/Int|): R|kotlin/Unit| {
     }
-    public final [ResolvedTo(CONTRACTS)] val delegate: R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| = object : R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] 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|>()
         }
@@ -398,13 +398,13 @@ FILE: [ResolvedTo(IMPORTS)] delegates.kt
 
     }
 
-        public [ResolvedTo(CONTRACTS)] get(): R|kotlin/properties/ReadWriteProperty<kotlin/Any?, kotlin/Int>|
+        public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] 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 [ResolvedTo(CONTRACTS)] val valueWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [ResolvedTo(CONTRACTS)] 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 [ResolvedTo(CONTRACTS)] var variableWithExplicitType: R|kotlin/Int|by delegate#
@@ -414,11 +414,11 @@ FILE: [ResolvedTo(IMPORTS)] delegates.kt
         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 [ResolvedTo(CONTRACTS)] var variableWithImplicitType: R|kotlin/Int|by R|/delegate|
-        public [ResolvedTo(CONTRACTS)] 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 [ResolvedTo(CONTRACTS)] set([ResolvedTo(CONTRACTS)] <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|)
         }
 

analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt

@@ -0,0 +1,18 @@
+fun ex<caret>pression(expression: IrConst<*>) {
+    when (val kind = expression.kind) {
+        is Kind.Null -> kind.valueOf(expression)
+        else -> {}
+    }
+}
+
+sealed class Kind<T>(val asString: String) {
+    @Suppress("UNCHECKED_CAST")
+    fun valueOf(aConst: IrConst<*>) = (aConst as IrConst<T>).value
+    object Null : Kind<Nothing?>("Null")
+    override fun toString() = asString
+}
+
+abstract class IrConst<T> {
+    abstract var kind: Kind<T>
+    abstract var value: T
+}

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

@@ -0,0 +1,596 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun expression([ResolvedTo(RAW_FIR)] expression: IrConst<*>): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] fun expression([ResolvedTo(RAW_FIR)] expression: IrConst<*>): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] fun expression([ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] expression: IrConst<*>): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(COMPANION_GENERATION)] fun expression([ResolvedTo(COMPANION_GENERATION)] expression: IrConst<*>): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] fun expression([ResolvedTo(SUPER_TYPES)] expression: IrConst<*>): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] fun expression([ResolvedTo(TYPES)] expression: R|IrConst<*>|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] fun expression([ResolvedTo(STATUS)] expression: R|IrConst<*>|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] fun expression([ResolvedTo(EXPECT_ACTUAL_MATCHING)] expression: R|IrConst<*>|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] fun expression([ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] expression: R|IrConst<*>|): R|kotlin/Unit| { LAZY_BLOCK }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(CONTRACTS)] fun expression([ResolvedTo(CONTRACTS)] expression: R|IrConst<*>|): R|kotlin/Unit| {
+        when ([ResolvedTo(RAW_FIR)] lval kind: <implicit> = expression#.kind#) {
+            ($subj$ is Kind.Null) ->  {
+                kind#.valueOf#(expression#)
+            }
+            else ->  {
+            }
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun expression([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] expression: R|IrConst<*>|): R|kotlin/Unit| {
+        when ([ResolvedTo(RAW_FIR)] lval kind: <implicit> = expression#.kind#) {
+            ($subj$ is Kind.Null) ->  {
+                kind#.valueOf#(expression#)
+            }
+            else ->  {
+            }
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] fun expression([ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] expression: R|IrConst<*>|): R|kotlin/Unit| {
+        when ([ResolvedTo(RAW_FIR)] lval kind: <implicit> = expression#.kind#) {
+            ($subj$ is Kind.Null) ->  {
+                kind#.valueOf#(expression#)
+            }
+            else ->  {
+            }
+        }
+
+    }
+    public? sealed [ResolvedTo(RAW_FIR)] class Kind<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] constructor<[ResolvedTo(RAW_FIR)] T>([ResolvedTo(RAW_FIR)] [CorrespondingProperty=/Kind.asString] asString: String): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|<local>/asString|
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Kind] get(): String
+
+        @Suppress[Unresolved](LAZY_EXPRESSION) public? final? [ResolvedTo(RAW_FIR)] fun valueOf([ResolvedTo(RAW_FIR)] aConst: IrConst<*>): <implicit> { LAZY_BLOCK }
+
+        public? final? [ResolvedTo(RAW_FIR)] object Null : Kind<Nothing?> {
+            private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<Kind<Nothing?>>
+            }
+
+        }
+
+        public? open? override [ResolvedTo(RAW_FIR)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public? abstract [ResolvedTo(RAW_FIR)] class IrConst<[ResolvedTo(RAW_FIR)] T> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(RAW_FIR)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind<T>
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind<T>): R|kotlin/Unit|
+
+        public? abstract [ResolvedTo(RAW_FIR)] var value: T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): T
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: T): R|kotlin/Unit|
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun expression([ResolvedTo(BODY_RESOLVE)] expression: R|IrConst<*>|): R|kotlin/Unit| {
+        when ([ResolvedTo(BODY_RESOLVE)] lval kind: R|Kind<out kotlin/Any?>| = R|<local>/expression|.R|SubstitutionOverride</IrConst.kind: R|Kind<CapturedType(*)>|>|) {
+            ($subj$ is R|Kind.Null|) ->  {
+                R|<local>/kind|.R|SubstitutionOverride</Kind.Null.valueOf: R|kotlin/Nothing?|>|(R|<local>/expression|)
+            }
+            else ->  {
+            }
+        }
+
+    }
+    public sealed [ResolvedTo(STATUS)] class Kind<[ResolvedTo(STATUS)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(STATUS)] [ContainingClassKey=Kind] constructor<[ResolvedTo(STATUS)] T>([ResolvedTo(STATUS)] [CorrespondingProperty=/Kind.asString] asString: R|kotlin/String|): R|Kind<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val asString: R|kotlin/String| = R|<local>/asString|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=Kind] get(): R|kotlin/String|
+
+        @R|kotlin/Suppress|[Types](names = vararg(String(UNCHECKED_CAST))) public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun valueOf([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] aConst: R|IrConst<*>|): R|T| {
+            ^valueOf (R|<local>/aConst| as R|IrConst<T>|).R|SubstitutionOverride</IrConst.value: R|T|>|
+        }
+
+        public final [ResolvedTo(STATUS)] object Null : R|Kind<kotlin/Nothing?>| {
+            private [ResolvedTo(STATUS)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                LAZY_super<R|Kind<kotlin/Nothing?>|>
+            }
+
+        }
+
+        public open override [ResolvedTo(STATUS)] fun toString(): <implicit> { LAZY_BLOCK }
+
+    }
+    public abstract [ResolvedTo(STATUS)] class IrConst<[ResolvedTo(STATUS)] T> : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(STATUS)] T>(): R|IrConst<T>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public abstract [ResolvedTo(STATUS)] var kind: R|Kind<T>|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] get(): R|Kind<T>|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] set([ResolvedTo(STATUS)] value: R|Kind<T>|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(STATUS)] var value: R|T|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] get(): R|T|
+            public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] set([ResolvedTo(STATUS)] value: R|T|): R|kotlin/Unit|
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] fakeOverride.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] fun expression([ResolvedTo(BODY_RESOLVE)] expression: R|IrConst<*>|): R|kotlin/Unit| {
+        when ([ResolvedTo(BODY_RESOLVE)] lval kind: R|Kind<out kotlin/Any?>| = R|<local>/expression|.R|SubstitutionOverride</IrConst.kind: R|Kind<CapturedType(*)>|>|) {
+            ($subj$ is R|Kind.Null|) ->  {
+                R|<local>/kind|.R|SubstitutionOverride</Kind.Null.valueOf: R|kotlin/Nothing?|>|(R|<local>/expression|)
+            }
+            else ->  {
+            }
+        }
+
+    }
+    public sealed [ResolvedTo(BODY_RESOLVE)] class Kind<[ResolvedTo(BODY_RESOLVE)] T> : R|kotlin/Any| {
+        protected [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Kind] constructor<[ResolvedTo(BODY_RESOLVE)] T>([ResolvedTo(BODY_RESOLVE)] [CorrespondingProperty=/Kind.asString] asString: R|kotlin/String|): R|Kind<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] [IsFromPrimaryConstructor=true] val asString: R|kotlin/String| = R|<local>/asString|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Kind] get(): R|kotlin/String|
+
+        @R|kotlin/Suppress|[Types](names = vararg(String(UNCHECKED_CAST))) public final [ResolvedTo(BODY_RESOLVE)] fun valueOf([ResolvedTo(BODY_RESOLVE)] aConst: R|IrConst<*>|): R|T| {
+            ^valueOf (R|<local>/aConst| as R|IrConst<T>|).R|SubstitutionOverride</IrConst.value: R|T|>|
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] object Null : R|Kind<kotlin/Nothing?>| {
+            private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Null] constructor(): R|Kind.Null| {
+                super<R|Kind<kotlin/Nothing?>|>(String(Null))
+            }
+
+        }
+
+        public open override [ResolvedTo(BODY_RESOLVE)] fun toString(): R|kotlin/String| {
+            ^toString this@R|/Kind|.R|/Kind.asString|
+        }
+
+    }
+    public abstract [ResolvedTo(BODY_RESOLVE)] class IrConst<[ResolvedTo(BODY_RESOLVE)] T> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] constructor<[ResolvedTo(BODY_RESOLVE)] T>(): R|IrConst<T>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] var kind: R|Kind<T>|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] get(): R|Kind<T>|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] set([ResolvedTo(BODY_RESOLVE)] value: R|Kind<T>|): R|kotlin/Unit|
+
+        public abstract [ResolvedTo(BODY_RESOLVE)] var value: R|T|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] get(): R|T|
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] set([ResolvedTo(BODY_RESOLVE)] value: R|T|): R|kotlin/Unit|
+
+    }

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

@@ -235,7 +235,7 @@ FILE: [ResolvedTo(IMPORTS)] functionWithGenericExpectedTypeInside.kt
         }
 
     }
-    public final [ResolvedTo(CONTRACTS)] fun bar(): R|Bar| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun bar(): R|Bar| {
         ^bar R|/Bar.Bar|()
     }
     public final [ResolvedTo(BODY_RESOLVE)] fun resolveMe(): R|kotlin/Unit| {

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

@@ -96,7 +96,7 @@ FILE: [ResolvedTo(IMPORTS)] topLevelFunctionsWithImplicitType.kt
     }
     public final [ResolvedTo(CONTRACTS)] fun receive([ResolvedTo(CONTRACTS)] value: R|kotlin/String|): R|kotlin/Unit| {
     }
-    public final [ResolvedTo(CONTRACTS)] fun functionWithLazyBody(): R|kotlin/String| {
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] fun functionWithLazyBody(): R|kotlin/String| {
         ^functionWithLazyBody String(42)
     }
 

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java

@@ -78,6 +78,12 @@ public class FirOutOfContentRootLazyDeclarationResolveTestGenerated extends Abst
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/enumEntry.kt");
     }
 
+    @Test
+    @TestMetadata("fakeOverride.kt")
+    public void testFakeOverride() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt");
+    }
+
     @Test
     @TestMetadata("functionWithParameter.kt")
     public void testFunctionWithParameter() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java

@@ -78,6 +78,12 @@ public class FirSourceLazyDeclarationResolveTestGenerated extends AbstractFirSou
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/enumEntry.kt");
     }
 
+    @Test
+    @TestMetadata("fakeOverride.kt")
+    public void testFakeOverride() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt");
+    }
+
     @Test
     @TestMetadata("functionWithParameter.kt")
     public void testFunctionWithParameter() throws Exception {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
-import org.jetbrains.kotlin.fir.declarations.utils.hasExplicitBackingField
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
@@ -29,6 +28,7 @@ import org.jetbrains.kotlin.fir.delegatedWrapperData
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
+import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -72,8 +72,8 @@ fun <F : FirClassLikeDeclaration> F.runContractAndBodiesResolutionForLocalClass(
     localClassesNavigationInfo: LocalClassesNavigationInfo,
     firTowerDataContextCollector: FirTowerDataContextCollector? = null
 ): F {
-    val prevDesignation =
-        (components.context.returnTypeCalculator as? ReturnTypeCalculatorWithJump)?.designationMapForLocalClasses ?: emptyMap()
+    val currentReturnTypeCalculator = components.context.returnTypeCalculator as? ReturnTypeCalculatorWithJump
+    val prevDesignation = currentReturnTypeCalculator?.designationMapForLocalClasses ?: emptyMap()
 
     val (designationMap, targetedClasses) = localClassesNavigationInfo.run {
         (prevDesignation + designationMap) to
@@ -81,13 +81,13 @@ fun <F : FirClassLikeDeclaration> F.runContractAndBodiesResolutionForLocalClass(
     }
 
     val implicitBodyResolveComputationSession =
-        ((components.returnTypeCalculator as? ReturnTypeCalculatorWithJump)?.implicitBodyResolveComputationSession
-            ?: ImplicitBodyResolveComputationSession())
+        currentReturnTypeCalculator?.implicitBodyResolveComputationSession ?: ImplicitBodyResolveComputationSession()
+
     val returnTypeCalculator = ReturnTypeCalculatorWithJump(
         components.scopeSession,
         implicitBodyResolveComputationSession,
         designationMap,
-        createTransformer = components.returnTypeCalculator.getTransformerCreator()
+        nonLocalDeclarationResolver = currentReturnTypeCalculator,
     )
 
     val newContext = components.context.createSnapshotForLocalClasses(returnTypeCalculator, targetedClasses)
@@ -107,25 +107,6 @@ fun <F : FirClassLikeDeclaration> F.runContractAndBodiesResolutionForLocalClass(
     return this.transform(transformer, resolutionMode)
 }
 
-private fun ReturnTypeCalculator.getTransformerCreator() = when (this) {
-    is ReturnTypeCalculatorWithJump -> createTransformer
-    else -> ::FirDesignatedBodyResolveTransformerForReturnTypeCalculator
-}
-
-fun createReturnTypeCalculatorForIDE(
-    scopeSession: ScopeSession,
-    implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-    createTransformer: (
-        designation: Iterator<FirElement>,
-        FirSession,
-        ScopeSession,
-        ImplicitBodyResolveComputationSession,
-        ReturnTypeCalculator,
-        BodyResolveContext?
-    ) -> FirDesignatedBodyResolveTransformerForReturnTypeCalculator
-): ReturnTypeCalculator =
-    ReturnTypeCalculatorWithJump(scopeSession, implicitBodyResolveComputationSession, createTransformer = createTransformer)
-
 open class FirImplicitAwareBodyResolveTransformer(
     session: FirSession,
     scopeSession: ScopeSession,
@@ -190,18 +171,11 @@ open class FirImplicitAwareBodyResolveTransformer(
     }
 }
 
-private class ReturnTypeCalculatorWithJump(
-    private val scopeSession: ScopeSession,
+open class ReturnTypeCalculatorWithJump(
+    protected val scopeSession: ScopeSession,
     val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
     val designationMapForLocalClasses: Map<FirCallableDeclaration, List<FirClassLikeDeclaration>> = mapOf(),
-    val createTransformer: (
-        designation: Iterator<FirElement>,
-        session: FirSession,
-        scopeSession: ScopeSession,
-        implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
-        returnTypeCalculator: ReturnTypeCalculator,
-        outerBodyResolveContext: BodyResolveContext?
-    ) -> FirDesignatedBodyResolveTransformerForReturnTypeCalculator = ::FirDesignatedBodyResolveTransformerForReturnTypeCalculator,
+    private val nonLocalDeclarationResolver: ReturnTypeCalculatorWithJump? = null,
 ) : ReturnTypeCalculator() {
     override val fakeOverrideTypeCalculator: FakeOverrideTypeCalculator = FakeOverrideTypeCalculatorWithJump()
 
@@ -287,19 +261,27 @@ private class ReturnTypeCalculatorWithJump(
         }
     }
 
-    @OptIn(PrivateForInline::class)
     private fun computeReturnTypeRef(declaration: FirCallableDeclaration): FirResolvedTypeRef {
         (declaration.returnTypeRef as? FirResolvedTypeRef)?.let { return it }
-        // To properly transform and resolve declaration's type, we need to use its module's session
-        val session = declaration.moduleData.session
         val symbol = declaration.symbol
         require(!symbol.isSubstitutionOrIntersectionOverride) {
             "fakeOverrideSubstitution was not calculated for substitution or intersection override: $symbol with ${declaration.returnTypeRef}"
         }
 
+        return resolveDeclaration(declaration)
+    }
+
+    @OptIn(PrivateForInline::class)
+    protected open fun resolveDeclaration(declaration: FirCallableDeclaration): FirResolvedTypeRef {
+        // To properly transform and resolve declaration's type, we need to use its module's session
+        val session = declaration.moduleData.session
+        val symbol = declaration.symbol
+
         val (designation, outerBodyResolveContext) = if (declaration in designationMapForLocalClasses) {
             designationMapForLocalClasses.getValue(declaration) to outerBodyResolveContext
         } else {
+            nonLocalDeclarationResolver?.let { return it.resolveDeclaration(declaration) }
+
             val provider = session.firProvider
             val file = provider.getFirCallableContainerFile(symbol)
 
@@ -321,7 +303,7 @@ private class ReturnTypeCalculatorWithJump(
         val previousTowerDataContexts = outerBodyResolveContext?.regularTowerDataContexts
         outerBodyResolveContext?.regularTowerDataContexts = outerTowerDataContexts!!
 
-        val transformer = createTransformer(
+        val transformer = FirDesignatedBodyResolveTransformerForReturnTypeCalculator(
             (designation.drop(1) + declaration).iterator(),
             session,
             scopeSession,