[LL FIR] rename ensurePhase -> checkPhase to distinguish with ensureResolved

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

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -49,7 +49,7 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return
-        designation.declaration.ensurePhase(FirResolvePhase.STATUS)
+        designation.declaration.checkPhase(FirResolvePhase.STATUS)
 
         val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator()
 
@@ -60,20 +60,20 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
         }
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         val unresolvedAnnotation = declaration.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef }
         check(unresolvedAnnotation == null) {
             "Unexpected annotationTypeRef annotation, expected resolvedType but actual ${unresolvedAnnotation?.annotationTypeRef}"
         }
         when (declaration) {
             is FirSimpleFunction, is FirConstructor, is FirAnonymousInitializer ->
-                declaration.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+                declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
             is FirProperty -> {
-                declaration.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+                declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
 //                declaration.getter?.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
 //                declaration.setter?.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
             }

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

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -55,14 +55,14 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
         }
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirClass, is FirTypeAlias ->
-                declaration.ensurePhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
+                declaration.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
             is FirFunction, is FirProperty, is FirEnumEntry, is FirField, is FirAnonymousInitializer, is FirErrorProperty ->
                 Unit
             else ->

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

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesigna
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
 /**
  * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children
@@ -52,7 +52,7 @@ internal class LLFirDesignatedBodyResolveTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return
-        designation.declaration.ensurePhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+        designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
 
         ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.BODY_RESOLVE) {
             phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) {
@@ -62,16 +62,16 @@ internal class LLFirDesignatedBodyResolveTransformer(
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirSimpleFunction, is FirConstructor, is FirTypeAlias, is FirField, is FirAnonymousInitializer ->
-                declaration.ensurePhase(FirResolvePhase.BODY_RESOLVE)
+                declaration.checkPhase(FirResolvePhase.BODY_RESOLVE)
             is FirProperty -> {
-                declaration.ensurePhase(FirResolvePhase.BODY_RESOLVE)
+                declaration.checkPhase(FirResolvePhase.BODY_RESOLVE)
 //                declaration.getter?.ensurePhase(FirResolvePhase.BODY_RESOLVE)
 //                declaration.setter?.ensurePhase(FirResolvePhase.BODY_RESOLVE)
             }

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesigna
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
 /**
  * Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children
@@ -45,7 +45,7 @@ internal class LLFirDesignatedContractsResolveTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.CONTRACTS) return
-        designation.declaration.ensurePhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+        designation.declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
 
         FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
         ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.CONTRACTS) {
@@ -56,16 +56,16 @@ internal class LLFirDesignatedContractsResolveTransformer(
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.CONTRACTS)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirSimpleFunction, is FirConstructor, is FirAnonymousInitializer ->
-                declaration.ensurePhase(FirResolvePhase.CONTRACTS)
+                declaration.checkPhase(FirResolvePhase.CONTRACTS)
             is FirProperty -> {
-                declaration.ensurePhase(FirResolvePhase.CONTRACTS)
+                declaration.checkPhase(FirResolvePhase.CONTRACTS)
 //                declaration.getter?.ensurePhase(FirResolvePhase.CONTRACTS)
 //                declaration.setter?.ensurePhase(FirResolvePhase.CONTRACTS)
             }

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesigna
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -39,7 +39,7 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.EXPECT_ACTUAL_MATCHING) return
-        designation.declaration.ensurePhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+        designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
 
         FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
         ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
@@ -50,16 +50,16 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
 
         declarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirSimpleFunction, is FirConstructor, is FirAnonymousInitializer ->
-                declaration.ensurePhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
+                declaration.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
             is FirProperty -> {
-                declaration.ensurePhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
+                declaration.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
             }
             is FirClass, is FirTypeAlias, is FirEnumEntry, is FirField -> Unit
             else -> error("Unexpected type: ${declaration::class.simpleName}")

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

@@ -29,11 +29,11 @@ internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
         }
 
         LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPANION_GENERATION)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         check(declaration.resolvePhase >= FirResolvePhase.COMPANION_GENERATION)
     }
 }

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

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesigna
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
 /**
  * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents
@@ -52,7 +52,7 @@ internal class LLFirDesignatedImplicitTypesTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return
-        designation.declaration.ensurePhase(FirResolvePhase.CONTRACTS)
+        designation.declaration.checkPhase(FirResolvePhase.CONTRACTS)
 
             ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
             phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
@@ -62,11 +62,11 @@ internal class LLFirDesignatedImplicitTypesTransformer(
 
         ideDeclarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirSimpleFunction -> check(declaration.returnTypeRef is FirResolvedTypeRef)
             is FirField -> check(declaration.returnTypeRef is FirResolvedTypeRef)

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
 /**
  * Transform designation into STATUS phase. Affects only for designation, target declaration, it's children and dependents
@@ -38,7 +38,7 @@ internal class LLFirDesignatedStatusResolveTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.STATUS) return
-        designation.declaration.ensurePhase(FirResolvePhase.TYPES)
+        designation.declaration.checkPhase(FirResolvePhase.TYPES)
 
         val transformer = FirDesignatedStatusResolveTransformerForIDE()
         ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.STATUS) {
@@ -49,13 +49,13 @@ internal class LLFirDesignatedStatusResolveTransformer(
 
         transformer.designationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.STATUS)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         if (declaration !is FirAnonymousInitializer) {
-            declaration.ensurePhase(FirResolvePhase.STATUS)
+            declaration.checkPhase(FirResolvePhase.STATUS)
         }
         when (declaration) {
             is FirSimpleFunction -> check(declaration.status is FirResolvedDeclarationStatus)

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeB
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 
 /**
  * Transform designation into SUPER_TYPES phase. Affects only for designation, target declaration, it's children and dependents
@@ -132,7 +132,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.SUPER_TYPES) return
-        designation.firFile.ensurePhase(FirResolvePhase.IMPORTS)
+        designation.firFile.checkPhase(FirResolvePhase.IMPORTS)
 
         val targetDesignation = if (designation.declaration !is FirClassLikeDeclaration) {
             val resolvableTarget = designation.path.lastOrNull()
@@ -154,19 +154,19 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
         }
 
         updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES)
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         when (declaration) {
             is FirFunction, is FirProperty, is FirEnumEntry, is FirField, is FirAnonymousInitializer -> Unit
             is FirRegularClass -> {
-                declaration.ensurePhase(FirResolvePhase.SUPER_TYPES)
+                declaration.checkPhase(FirResolvePhase.SUPER_TYPES)
                 check(declaration.superTypeRefs.all { it is FirResolvedTypeRef })
             }
             is FirTypeAlias -> {
-                declaration.ensurePhase(FirResolvePhase.SUPER_TYPES)
+                declaration.checkPhase(FirResolvePhase.SUPER_TYPES)
                 check(declaration.expandedTypeRef is FirResolvedTypeRef)
             }
             else -> error("Unexpected type: ${declaration::class.simpleName}")

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ensurePhase
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 
 /**
@@ -43,7 +43,7 @@ internal class LLFirDesignatedTypeResolverTransformer(
 
     override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
         if (designation.declaration.resolvePhase >= FirResolvePhase.TYPES) return
-        designation.declaration.ensurePhase(FirResolvePhase.SUPER_TYPES)
+        designation.declaration.checkPhase(FirResolvePhase.SUPER_TYPES)
 
         ResolveTreeBuilder.resolvePhase(designation.declaration, FirResolvePhase.TYPES) {
             phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) {
@@ -54,13 +54,13 @@ internal class LLFirDesignatedTypeResolverTransformer(
         declarationTransformer.ensureDesignationPassed()
         updatePhaseDeep(designation.declaration, FirResolvePhase.TYPES)
 
-        ensureResolved(designation.declaration)
-        ensureResolvedDeep(designation.declaration)
+        checkIsResolved(designation.declaration)
+        checkIsResolvedDeep(designation.declaration)
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) {
+    override fun checkIsResolved(declaration: FirDeclaration) {
         if (declaration !is FirAnonymousInitializer) {
-            declaration.ensurePhase(FirResolvePhase.TYPES)
+            declaration.checkPhase(FirResolvePhase.TYPES)
         }
         when (declaration) {
             is FirFunction -> {
@@ -73,8 +73,8 @@ internal class LLFirDesignatedTypeResolverTransformer(
             is FirProperty -> {
                 check(declaration.returnTypeRef is FirResolvedTypeRef || declaration.returnTypeRef is FirImplicitTypeRef)
                 check(declaration.receiverTypeRef?.let { it is FirResolvedTypeRef } ?: true)
-                declaration.getter?.run(::ensureResolved)
-                declaration.setter?.run(::ensureResolved)
+                declaration.getter?.run(::checkIsResolved)
+                declaration.setter?.run(::checkIsResolved)
             }
             is FirField -> check(declaration.returnTypeRef is FirResolvedTypeRef || declaration.returnTypeRef is FirImplicitTypeRef)
             is FirClass, is FirTypeAlias, is FirAnonymousInitializer -> Unit

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

@@ -55,5 +55,5 @@ internal class LLFirFileAnnotationsResolveTransformer(
         }
     }
 
-    override fun ensureResolved(declaration: FirDeclaration) = error("Not implemented")
+    override fun checkIsResolved(declaration: FirDeclaration) = error("Not implemented")
 }

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

@@ -14,12 +14,14 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 internal interface LLFirLazyTransformer {
     fun transformDeclaration(phaseRunner: LLFirPhaseRunner)
-    fun ensureResolved(declaration: FirDeclaration)
-    fun ensureResolvedDeep(declaration: FirDeclaration) {
+
+    fun checkIsResolved(declaration: FirDeclaration)
+
+    fun checkIsResolvedDeep(declaration: FirDeclaration) {
         if (!enableDeepEnsure) return
-        ensureResolved(declaration)
+        checkIsResolved(declaration)
         if (declaration is FirRegularClass) {
-            declaration.declarations.forEach(::ensureResolvedDeep)
+            declaration.declarations.forEach(::checkIsResolvedDeep)
         }
     }
 
@@ -77,7 +79,7 @@ internal interface LLFirLazyTransformer {
 
         val DUMMY = object : LLFirLazyTransformer {
             override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit
-            override fun ensureResolved(declaration: FirDeclaration) = error("Not implemented")
+            override fun checkIsResolved(declaration: FirDeclaration) = error("Not implemented")
         }
     }
 }

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

@@ -11,20 +11,20 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
 
-internal fun FirDeclaration.ensurePhase(firResolvePhase: FirResolvePhase) =
+internal fun FirDeclaration.checkPhase(firResolvePhase: FirResolvePhase) =
     check(resolvePhase >= firResolvePhase) {
         "Element phase required to be $firResolvePhase but element resolved to $resolvePhase"
     }
 
-internal fun FirDeclarationDesignation.ensurePathPhase(firResolvePhase: FirResolvePhase) =
-    path.forEach { it.ensurePhase(firResolvePhase) }
+internal fun FirDeclarationDesignation.checkPathPhase(firResolvePhase: FirResolvePhase) =
+    path.forEach { it.checkPhase(firResolvePhase) }
 
-internal fun FirDeclarationDesignation.ensureDesignation(firResolvePhase: FirResolvePhase) {
-    ensurePathPhase(firResolvePhase)
-    declaration.ensurePhase(firResolvePhase)
+internal fun FirDeclarationDesignation.checkDesignationPhase(firResolvePhase: FirResolvePhase) {
+    checkPathPhase(firResolvePhase)
+    declaration.checkPhase(firResolvePhase)
 }
-internal fun FirDeclarationDesignation.ensurePhaseForClasses(firResolvePhase: FirResolvePhase) {
-    ensurePathPhase(firResolvePhase)
+internal fun FirDeclarationDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) {
+    checkPathPhase(firResolvePhase)
     if (declaration is FirClassLikeDeclaration) {
         check(declaration.resolvePhase >= firResolvePhase) {
             "Expected $firResolvePhase but found ${declaration.resolvePhase}"