[FIR IDE] Split names of withRef function to phase and type versions

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.isVisibleInClass
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.originalForIntersectionOverrideAttr
 import org.jetbrains.kotlin.fir.originalForSubstitutionOverride
@@ -21,7 +20,6 @@ import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.components.KtOverrideInfoProvider
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.fir.buildSymbol
-import org.jetbrains.kotlin.idea.frontend.api.fir.utils.FirRefWithValidityCheck
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.idea.frontend.api.tokens.ValidityToken
@@ -39,10 +37,10 @@ class KtFirOverrideInfoProvider(
         require(classSymbol is KtFirSymbol<*>)
 
         // Inspecting visibility requires resolving to status
-        return memberSymbol.firRef.withFirWithResolveAllowed outer@{ memberFir ->
+        return memberSymbol.firRef.withFirWithPossibleResolveInside(FirResolvePhase.STATUS) outer@{ memberFir ->
             if (memberFir !is FirCallableDeclaration) return@outer false
 
-            classSymbol.firRef.withFirWithResolveAllowed inner@{ parentClassFir ->
+            classSymbol.firRef.withFirWithPossibleResolveInside inner@{ parentClassFir ->
                 if (parentClassFir !is FirClass) return@inner false
 
                 memberFir.isVisibleInClass(parentClassFir)
@@ -55,10 +53,10 @@ class KtFirOverrideInfoProvider(
         require(parentClassSymbol is KtFirSymbol<*>)
 
         // Inspecting implementation status requires resolving to status
-        return memberSymbol.firRef.withFirWithResolveAllowed outer@{ memberFir ->
+        return memberSymbol.firRef.withFirWithPossibleResolveInside(FirResolvePhase.STATUS) outer@{ memberFir ->
             if (memberFir !is FirCallableDeclaration) return@outer null
 
-            parentClassSymbol.firRef.withFirWithResolveAllowed inner@{ parentClassFir ->
+            parentClassSymbol.firRef.withFirWithPossibleResolveInside inner@{ parentClassFir ->
                 if (parentClassFir !is FirClass) return@inner null
 
                 memberFir.symbol.getImplementationStatus(
@@ -102,13 +100,4 @@ class KtFirOverrideInfoProvider(
 
         return member
     }
-}
-
-/**
- * Convenience function.
- *
- * We use [FirRefWithValidityCheck.withFirWithPossibleResolveInside] instead of [FirRefWithValidityCheck.withFir] because we want to be able
- * to call this function inside itself - and it requires write lock, since each layer might want to call resolve and to use write lock.
- */
-private inline fun <D : FirDeclaration, R> FirRefWithValidityCheck<D>.withFirWithResolveAllowed(crossinline action: (D) -> R): R =
-    withFirWithPossibleResolveInside(phase = FirResolvePhase.RAW_FIR, action)
+}

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt

@@ -69,7 +69,7 @@ internal fun FirRefWithValidityCheck<FirRegularClass>.superTypesAndAnnotationsLi
         if(fir.resolvePhase >= FirResolvePhase.SUPER_TYPES) {
             fir.superTypeRefs.mapToTypeAndAnnotations(this, builder)
         } else null
-    } ?: withFirWithPossibleResolveInside(ResolveType.NoResolve) { fir ->
+    } ?: withFirByTypeWithPossibleResolveInside(ResolveType.NoResolve) { fir ->
         fir.resolveSupertypesInTheAir(builder.rootSession).mapToTypeAndAnnotations(this, builder)
     }
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/annotations/KtFirAnnotationCall.kt

@@ -31,7 +31,7 @@ internal class KtFirAnnotationCall(
     }
 
     override val classId: ClassId? by cached {
-        containingDeclaration.withFirWithPossibleResolveInside(ResolveType.AnnotationType) { fir ->
+        containingDeclaration.withFirByTypeWithPossibleResolveInside(ResolveType.AnnotationType) { fir ->
             annotationCallRef.getClassId(fir.moduleData.session)
         }
     }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/annotations/firAnnotationUtils.kt

@@ -24,11 +24,11 @@ internal fun FirRefWithValidityCheck<FirAnnotatedDeclaration>.toAnnotationsList(
 }
 
 internal fun FirRefWithValidityCheck<FirAnnotatedDeclaration>.containsAnnotation(classId: ClassId): Boolean =
-    withFir(ResolveType.AnnotationType) { fir ->
+    withFirByType(ResolveType.AnnotationType) { fir ->
         fir.annotations.any { it.getClassId(fir.moduleData.session) == classId }
     }
 
 internal fun FirRefWithValidityCheck<FirAnnotatedDeclaration>.getAnnotationClassIds(): Collection<ClassId> =
-    withFir(ResolveType.AnnotationType) { fir ->
+    withFirByType(ResolveType.AnnotationType) { fir ->
         fir.annotations.mapNotNull { it.getClassId(fir.moduleData.session) }
     }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt

@@ -58,10 +58,10 @@ internal class FirRefWithValidityCheck<out D : FirDeclaration>(fir: D, resolveSt
      * Runs [action] with fir element with write action hold
      * Consider using this then [action] may call some resolve
      */
-    inline fun <R> withFirWithPossibleResolveInside(
+    inline fun <R> withFirByTypeWithPossibleResolveInside(
         resolveType: ResolveType = ResolveType.NoResolve,
         crossinline action: (fir: D) -> R
-    ): R = withFir(resolveType, action)
+    ): R = withFirByType(resolveType, action)
 
     val resolveState
         get() = resolveStateWeakRef.get() ?: throw EntityWasGarbageCollectedException("FirModuleResolveState")
@@ -71,7 +71,7 @@ internal class FirRefWithValidityCheck<out D : FirDeclaration>(fir: D, resolveSt
             withFir(phase) { fir -> createValue(fir) }
         }
 
-    inline fun <R> withFir(type: ResolveType, crossinline action: (fir: D) -> R): R {
+    inline fun <R> withFirByType(type: ResolveType, crossinline action: (fir: D) -> R): R {
         token.assertIsValidAndAccessible()
         val fir = firWeakRef.get()
             ?: throw EntityWasGarbageCollectedException("FirElement")
@@ -82,7 +82,7 @@ internal class FirRefWithValidityCheck<out D : FirDeclaration>(fir: D, resolveSt
 
     inline fun <R> withFirAndCache(type: ResolveType, crossinline createValue: (fir: D) -> R) =
         ValidityAwareCachedValue(token) {
-            withFir(type) { fir -> createValue(fir) }
+            withFirByType(type) { fir -> createValue(fir) }
         }
 }