From 481becb342bbe695500355cdb68a521c4a0b2cfe Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Wed, 26 Apr 2023 14:49:26 +0200 Subject: [PATCH] [LL FIR] implement LLFirReturnTypeCalculatorWithJump To provide the correct designation and locks strategy ^KT-56550 ^KT-58083 Fixed --- .../api/fir/LLFirGlobalResolveComponents.kt | 6 + .../fir/PersistentCheckerContextFactory.kt | 18 +- ...solveTransformerForReturnTypeCalculator.kt | 99 --- ...BasedTransformerForReturnTypeCalculator.kt | 81 --- .../LLFirAbstractBodyTargetResolver.kt | 12 +- ...irAnnotationArgumentMappingLazyResolver.kt | 2 +- .../LLFirAnnotationArgumentsLazyResolver.kt | 2 +- .../fir/transformers/LLFirBodyLazyResolver.kt | 2 +- .../LLFirImplicitTypesLazyResolver.kt | 9 +- .../LLFirReturnTypeCalculatorWithJump.kt | 53 ++ .../testdata/lazyResolve/delegates.txt | 14 +- .../testdata/lazyResolve/fakeOverride.kt | 18 + .../testdata/lazyResolve/fakeOverride.txt | 596 ++++++++++++++++++ .../functionWithGenericExpectedTypeInside.txt | 2 +- .../topLevelFunctionsWithImplicitType.txt | 2 +- ...otLazyDeclarationResolveTestGenerated.java | 6 + ...ceLazyDeclarationResolveTestGenerated.java | 6 + .../body/resolve/FirImplicitBodyResolve.kt | 60 +- 18 files changed, 742 insertions(+), 246 deletions(-) delete mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt delete mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt create mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.txt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirGlobalResolveComponents.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirGlobalResolveComponents.kt index 4f39c9e6918..554aabbf3fa 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirGlobalResolveComponents.kt +++ b/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() diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt index b3708cecef8..90d6a7d1118 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/PersistentCheckerContextFactory.kt +++ b/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) } } \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt deleted file mode 100644 index 4575aa0135e..00000000000 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt +++ /dev/null @@ -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, - session: FirSession, - scopeSession: ScopeSession, - implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession, - returnTypeCalculator: ReturnTypeCalculator, - outerBodyResolveContext: BodyResolveContext?, -): FirDesignatedBodyResolveTransformerForReturnTypeCalculator { - - val designationList = mutableListOf() - 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, - 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.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() - 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, 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) - } -} diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt deleted file mode 100644 index 75a5094a90c..00000000000 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt +++ /dev/null @@ -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, - session: FirSession, - scopeSession: ScopeSession, - implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession, - returnTypeCalculator: ReturnTypeCalculator, - outerBodyResolveContext: BodyResolveContext?, -): FirDesignatedBodyResolveTransformerForReturnTypeCalculator { - - val designationList = mutableListOf() - 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, - 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.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) - } -} diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt index eacdb730257..064087887a6 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt +++ b/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 diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentMappingLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentMappingLazyResolver.kt index 134d4fc8711..c07771ea15b 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentMappingLazyResolver.kt +++ b/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) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt index ae6ac550a1f..1ca4ef13374 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt +++ b/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) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt index 42068702d33..91b2be6654c 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt +++ b/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 diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt index e70dea653b0..8786acae7f1 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt +++ b/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 } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt new file mode 100644 index 00000000000..ecddf502654 --- /dev/null +++ b/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 + } +} diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt b/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt index 9f4e79c1f23..08e89e952e7 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/delegates.txt +++ b/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| = object : R|kotlin/properties/ReadWriteProperty| { + public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] val delegate: R|kotlin/properties/ReadWriteProperty| = object : R|kotlin/properties/ReadWriteProperty| { private [ResolvedTo(RAW_FIR)] [ContainingClassKey=] constructor(): R|| { super() } @@ -398,13 +398,13 @@ FILE: [ResolvedTo(IMPORTS)] delegates.kt } - public [ResolvedTo(CONTRACTS)] get(): R|kotlin/properties/ReadWriteProperty| + public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] get(): R|kotlin/properties/ReadWriteProperty| 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|(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)] : R|kotlin/Int|): R|kotlin/Unit| { D|/variableWithExplicitType|.setValue#(Null(null), ::R|/variableWithExplicitType|, R|/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|(Null(null), ::R|/variableWithImplicitType|) } - public [ResolvedTo(CONTRACTS)] set([ResolvedTo(CONTRACTS)] : R|kotlin/Int|): R|kotlin/Unit| { + public [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] set([ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] : R|kotlin/Int|): R|kotlin/Unit| { D|/variableWithImplicitType|.R|SubstitutionOverride|(Null(null), ::R|/variableWithImplicitType|, R|/variableWithImplicitType|) } diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt b/analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt new file mode 100644 index 00000000000..d5cbc1f9cdc --- /dev/null +++ b/analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.kt @@ -0,0 +1,18 @@ +fun expression(expression: IrConst<*>) { + when (val kind = expression.kind) { + is Kind.Null -> kind.valueOf(expression) + else -> {} + } +} + +sealed class Kind(val asString: String) { + @Suppress("UNCHECKED_CAST") + fun valueOf(aConst: IrConst<*>) = (aConst as IrConst).value + object Null : Kind("Null") + override fun toString() = asString +} + +abstract class IrConst { + abstract var kind: Kind + abstract var value: T +} diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.txt b/analysis/low-level-api-fir/testdata/lazyResolve/fakeOverride.txt new file mode 100644 index 00000000000..0e1a36b0d92 --- /dev/null +++ b/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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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: = 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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: = 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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: = 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| { + LAZY_super + } + + public? final? [ResolvedTo(RAW_FIR)] [IsFromPrimaryConstructor=true] val asString: String = R|/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<*>): { LAZY_BLOCK } + + public? final? [ResolvedTo(RAW_FIR)] object Null : Kind { + private [ResolvedTo(RAW_FIR)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super> + } + + } + + public? open? override [ResolvedTo(RAW_FIR)] fun toString(): { 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| { + LAZY_super + } + + public? abstract [ResolvedTo(RAW_FIR)] var kind: Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] get(): Kind + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=IrConst] set([ResolvedTo(RAW_FIR)] value: Kind): 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| = R|/expression|.R|SubstitutionOverride|>|) { + ($subj$ is R|Kind.Null|) -> { + R|/kind|.R|SubstitutionOverride|(R|/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| { + LAZY_super + } + + public final [ResolvedTo(STATUS)] [IsFromPrimaryConstructor=true] val asString: R|kotlin/String| = R|/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|/aConst| as R|IrConst|).R|SubstitutionOverride| + } + + public final [ResolvedTo(STATUS)] object Null : R|Kind| { + private [ResolvedTo(STATUS)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + LAZY_super|> + } + + } + + public open override [ResolvedTo(STATUS)] fun toString(): { 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| { + LAZY_super + } + + public abstract [ResolvedTo(STATUS)] var kind: R|Kind| + public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] get(): R|Kind| + public [ResolvedTo(STATUS)] [ContainingClassKey=IrConst] set([ResolvedTo(STATUS)] value: R|Kind|): 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| = R|/expression|.R|SubstitutionOverride|>|) { + ($subj$ is R|Kind.Null|) -> { + R|/kind|.R|SubstitutionOverride|(R|/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| { + super() + } + + public final [ResolvedTo(BODY_RESOLVE)] [IsFromPrimaryConstructor=true] val asString: R|kotlin/String| = R|/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|/aConst| as R|IrConst|).R|SubstitutionOverride| + } + + public final [ResolvedTo(BODY_RESOLVE)] object Null : R|Kind| { + private [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Null] constructor(): R|Kind.Null| { + super|>(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| { + super() + } + + public abstract [ResolvedTo(BODY_RESOLVE)] var kind: R|Kind| + public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] get(): R|Kind| + public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=IrConst] set([ResolvedTo(BODY_RESOLVE)] value: R|Kind|): 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| + + } diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithGenericExpectedTypeInside.txt b/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithGenericExpectedTypeInside.txt index 5b017b2f871..ccc6240f603 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/functions/functionWithGenericExpectedTypeInside.txt +++ b/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| { diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt b/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt index 2ced31a7a64..09c7624486a 100644 --- a/analysis/low-level-api-fir/testdata/lazyResolve/topLevelFunctionsWithImplicitType.txt +++ b/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) } diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java index d1e40dcbb49..5568973fa14 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java +++ b/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 { diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java index 1c5511b684c..4b2b0af2b11 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java +++ b/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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 72419db6741..48991ca2bcd 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/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.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.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.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, - 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> = mapOf(), - val createTransformer: ( - designation: Iterator, - 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,