[LL FIR] LLFirLazyResolver: implement checkIsResolved

To simplify logic and avoid boilerplate

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator.calculateAnnotations
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.expressionGuard
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
@@ -35,13 +34,9 @@ internal object LLFirAnnotationArgumentMappingLazyResolver : LLFirLazyResolver(F
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
+        if (target !is FirAnnotationContainer) return
-        if (target is FirAnnotationContainer) {
+        checkAnnotationArgumentsMappingIsResolved(target)
-            checkAnnotationArgumentsMappingIsResolved(target)
-        }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
 import org.jetbrains.kotlin.fir.FirSession
@@ -33,11 +32,6 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso
         val resolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, session, scopeSession, towerDataContextCollector)
         resolver.resolveDesignation()
     }
-
-    override fun checkIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
-        checkNestedDeclarationsAreResolved(target)
-    }
 }
 
 private class LLFirAnnotationArgumentsTargetResolver(

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

@@ -48,8 +48,7 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
         when (target) {
             is FirValueParameter -> checkDefaultValueIsResolved(target)
             is FirVariable -> checkInitializerIsResolved(target)
@@ -59,8 +58,6 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R
             }
             is FirFunction -> checkBodyIsResolved(target)
         }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 
@@ -146,7 +143,8 @@ private class LLFirBodyTargetResolver(
             is FirScript -> resolve(target, BodyStateKeepers.SCRIPT)
             is FirDanglingModifierList,
             is FirFileAnnotationsContainer,
-            is FirTypeAlias -> {
+            is FirTypeAlias,
+            -> {
                 // No bodies here
             }
             else -> throwUnexpectedFirElementError(target)

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockPro
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeprecationProviderIsResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.utils.errors.requireIsInstance
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
@@ -45,14 +44,11 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
         when (target) {
             is FirClassLikeDeclaration -> checkDeprecationProviderIsResolved(target, target.deprecationsProvider)
             is FirCallableDeclaration -> checkDeprecationProviderIsResolved(target, target.deprecationsProvider)
         }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.blockGuard
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isCallableWithSpecialBody
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
@@ -32,12 +31,9 @@ internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.C
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
+        if (target !is FirContractDescriptionOwner) return
-        if (target is FirContractDescriptionOwner) {
+        // TODO checkContractDescriptionIsResolved(declaration)
-            // TODO checkContractDescriptionIsResolved(declaration)
-        }
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 
@@ -67,7 +63,8 @@ private class LLFirContractsTargetResolver(
             is FirAnonymousInitializer,
             is FirScript,
             is FirFileAnnotationsContainer,
-            is FirDanglingModifierList -> {
+            is FirDanglingModifierList,
+            -> {
                 // No contracts here
                 check(target !is FirContractDescriptionOwner) {
                     "Unexpected contract description owner: $target (${target.javaClass.name})"

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkExpectForActualIsResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -29,13 +28,9 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
+        if (target !is FirMemberDeclaration || !target.canHaveExpectCounterPart()) return
-        if (target is FirMemberDeclaration && target.canHaveExpectCounterPart()) {
+        checkExpectForActualIsResolved(target)
-            checkExpectForActualIsResolved(target)
-        }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -28,10 +27,6 @@ internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(Fi
         val resolver = LLFirCompanionGenerationTargetResolver(target, lockProvider, session)
         resolver.resolveDesignation()
     }
-
-    override fun checkIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
-    }
 }
 
 private class LLFirCompanionGenerationTargetResolver(

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

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
@@ -32,13 +31,9 @@ internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePha
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
+        if (target !is FirCallableDeclaration) return
-        if (target is FirCallableDeclaration) {
+        checkReturnTypeRefIsResolved(target)
-            checkReturnTypeRefIsResolved(target)
-        }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 
@@ -79,7 +74,8 @@ internal class LLFirImplicitBodyTargetResolver(
             is FirScript,
             is FirAnonymousInitializer,
             is FirDanglingModifierList,
-            is FirFileAnnotationsContainer -> {
+            is FirFileAnnotationsContainer,
+            -> {
                 // No implicit bodies here
             }
             else -> throwUnexpectedFirElementError(target)

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -25,7 +26,18 @@ internal abstract class LLFirLazyResolver(
         towerDataContextCollector: FirResolveContextCollector?,
     )
 
-    abstract fun checkIsResolved(target: FirElementWithResolveState)
+    fun checkIsResolved(target: FirElementWithResolveState) {
+        target.checkPhase(resolverPhase)
+        phaseSpecificCheckIsResolved(target)
+        checkNestedDeclarationsAreResolved(target)
+    }
+
+    /**
+     * Check that phase-specific conditions are met
+     * Will be performed to resolved declaration and its nested declarations
+     * @see checkNestedDeclarationsAreResolved
+     */
+    protected open fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {}
 
     fun updatePhaseForDeclarationInternals(target: FirElementWithResolveState) {
         LLFirPhaseUpdater.updateDeclarationInternalsPhase(
@@ -39,8 +51,9 @@ internal abstract class LLFirLazyResolver(
         designation.forEachTarget(::checkIsResolved)
     }
 
-    protected fun checkNestedDeclarationsAreResolved(target: FirElementWithResolveState) {
+    private fun checkNestedDeclarationsAreResolved(target: FirElementWithResolveState) {
         if (target !is FirDeclaration) return
+
         checkFunctionParametersAreResolved(target)
         checkPropertyAccessorsAreResolved(target)
         checkPropertyBackingFieldIsResolved(target)

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -27,11 +26,6 @@ internal object LLFirSealedClassInheritorsLazyResolver : LLFirLazyResolver(FirRe
         val resolver = LLFirSealedClassInheritorsDesignatedResolver(target, lockProvider)
         resolver.resolveDesignation()
     }
-
-    override fun checkIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
-        checkNestedDeclarationsAreResolved(target)
-    }
 }
 
 

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarg
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeclarationStatusIsResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
@@ -43,16 +42,9 @@ internal object LLFirStatusLazyResolver : LLFirLazyResolver(FirResolvePhase.STAT
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        if (target !is FirAnonymousInitializer) {
+        if (target !is FirMemberDeclaration) return
-            target.checkPhase(resolverPhase)
+        checkDeclarationStatusIsResolved(target)
-        }
-
-        if (target is FirMemberDeclaration) {
-            checkDeclarationStatusIsResolved(target)
-        }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }
 

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

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirSingleRe
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
 import org.jetbrains.kotlin.fir.FirElementWithResolveState
 import org.jetbrains.kotlin.fir.FirSession
@@ -41,8 +40,7 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
         when (target) {
             is FirClass -> {
                 for (superTypeRef in target.superTypeRefs) {
@@ -53,8 +51,6 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S
             is FirTypeAlias -> {
                 checkTypeRefIsResolved(target.expandedTypeRef, typeRefName = "type alias expanded type", target)
             }
-
-            else -> {}
         }
     }
 }

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationTypeIsResolved
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReceiverTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
@@ -40,8 +39,7 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES)
         resolver.resolveDesignation()
     }
 
-    override fun checkIsResolved(target: FirElementWithResolveState) {
+    override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {
-        target.checkPhase(resolverPhase)
         if (target is FirAnnotationContainer) {
             checkAnnotationTypeIsResolved(target)
         }
@@ -63,11 +61,7 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES)
                     checkTypeRefIsResolved(bound, "type parameter bound", target)
                 }
             }
-
-            else -> {}
         }
-
-        checkNestedDeclarationsAreResolved(target)
     }
 }