Analysis API: use FirSymbol in KtFirSymbol's instead of FirDeclaration

^KT-50271 fixed

analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt

@@ -189,20 +189,20 @@ private object FirToKtConversionCreator {
 
     private val typeMapping: Map<KClass<*>, HLFunctionCallConversion> = mapOf(
         FirBasedSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0}.fir)",
+            "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
         ),
         FirClass::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol)",
             KtClassLikeSymbol::class.createType()
         ),
         FirClassSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir)",
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
             KtClassLikeSymbol::class.createType()
         ),
         FirRegularClass::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}) as KtNamedClassOrObjectSymbol",
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.symbol) as KtNamedClassOrObjectSymbol",
             KtNamedClassOrObjectSymbol::class.createType(),
             importsToAdd = listOf(
                 "org.jetbrains.kotlin.fir.declarations.FirRegularClass",
@@ -226,26 +226,26 @@ private object FirToKtConversionCreator {
             )
         ),
         FirValueParameter::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0})",
+            "firSymbolBuilder.buildSymbol({0}.symbol)",
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
         ),
         FirValueParameterSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0}.fir)",
+            "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirDeclaration")
         ),
         FirEnumEntrySymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.buildSymbol({0}.fir)",
+            "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),
         ),
         FirClassLikeSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir as FirClass)",
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
             KtClassLikeSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirClass")
         ),
         FirRegularClassSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0}.fir)",
+            "firSymbolBuilder.classifierBuilder.buildClassLikeSymbol({0})",
             KtClassLikeSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirRegularClass")
         ),
@@ -260,17 +260,17 @@ private object FirToKtConversionCreator {
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
         ),
         FirCallableSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0}.fir)",
+            "firSymbolBuilder.callableBuilder.buildCallableSymbol({0})",
             KtCallableSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration")
         ),
         FirTypeParameterSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0}.fir)",
+            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})",
             KtTypeParameterSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
         ),
         FirTypeParameter::class to HLFunctionCallConversion(
-            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0}.fir)",
+            "firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol({0})",
             KtTypeParameterSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
         ),
@@ -283,17 +283,17 @@ private object FirToKtConversionCreator {
             KtType::class.createType()
         ),
         FirPropertySymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir)",
+            "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0})",
             KtVariableSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty")
         ),
         FirBackingFieldSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir.propertySymbol.fir)",
+            "firSymbolBuilder.variableLikeBuilder.buildVariableSymbol({0}.fir.propertySymbol)",
             KtVariableSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirProperty")
         ),
         FirVariableSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol({0}.fir)",
+            "firSymbolBuilder.variableLikeBuilder.buildVariableLikeSymbol({0})",
             KtVariableLikeSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirVariable")
         ),
@@ -308,7 +308,7 @@ private object FirToKtConversionCreator {
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction")
         ),
         FirNamedFunctionSymbol::class to HLFunctionCallConversion(
-            "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0}.fir)",
+            "firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol({0})",
             KtFunctionLikeSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirSimpleFunction")
         ),

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/FirIdeDeserializedDeclarationSourceProvider.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSession
 import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -157,6 +158,10 @@ private fun FirElement.getAllowedPsi() = when (val source = source) {
 fun FirElement.findPsi(project: Project): PsiElement? =
     getAllowedPsi() ?: FirIdeDeserializedDeclarationSourceProvider.findPsi(this, project)
 
+
+fun FirBasedSymbol<*>.findPsi(): PsiElement? =
+    fir.findPsi(fir.moduleData.session)
+
 fun FirElement.findPsi(session: FirSession): PsiElement? =
     findPsi((session as FirIdeSession).project)
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.fir
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
@@ -23,8 +24,11 @@ class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionP
     }
 
     override fun getResolveState(contextSymbol: KtSymbol): FirModuleResolveState {
-        require(contextSymbol is KtFirSymbol<*>)
+        return when (contextSymbol) {
-        return contextSymbol.firRef.resolveState
+            is KtFirSymbol<*> -> contextSymbol.resolveState
+            is KtFirBackingFieldSymbol -> contextSymbol.resolveState
+            else -> error("Invalid symbol ${contextSymbol::class}")
+        }
     }
 
     override fun createAnalysisSession(

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirFieldImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
 import org.jetbrains.kotlin.fir.resolve.getContainingClass
 import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag
@@ -37,9 +36,9 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
@@ -58,10 +57,10 @@ internal class KtSymbolByFirBuilder private constructor(
     resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     val withReadOnlyCaching: Boolean,
-    private val symbolsCache: BuilderCache<FirDeclaration, KtSymbol>,
+    private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>,
-    private val extensionReceiverSymbolsCache: BuilderCache<FirCallableDeclaration, KtSymbol>,
+    private val extensionReceiverSymbolsCache: BuilderCache<FirCallableSymbol<*>, KtSymbol>,
-    private val filesCache: BuilderCache<FirFile, KtFileSymbol>,
+    private val filesCache: BuilderCache<FirFileSymbol, KtFileSymbol>,
-    private val backingFieldCache: BuilderCache<FirBackingField, KtBackingFieldSymbol>,
+    private val backingFieldCache: BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>,
     private val typesCache: BuilderCache<ConeKotlinType, KtType>,
 ) : ValidityTokenOwner {
     private val resolveState by weakRef(resolveState)
@@ -107,18 +106,22 @@ internal class KtSymbolByFirBuilder private constructor(
         )
     }
 
-    fun buildSymbol(fir: FirDeclaration): KtSymbol {
+    fun buildSymbol(fir: FirDeclaration): KtSymbol =
-        return when (fir) {
+        buildSymbol(fir.symbol)
-            is FirClassLikeDeclaration -> classifierBuilder.buildClassLikeSymbol(fir)
+
-            is FirTypeParameter -> classifierBuilder.buildTypeParameterSymbol(fir)
+    fun buildSymbol(firSymbol: FirBasedSymbol<*>): KtSymbol {
-            is FirCallableDeclaration -> callableBuilder.buildCallableSymbol(fir)
+        return when (firSymbol) {
-            else -> throwUnexpectedElementError(fir)
+            is FirClassLikeSymbol<*> -> classifierBuilder.buildClassLikeSymbol(firSymbol)
+            is FirTypeParameterSymbol -> classifierBuilder.buildTypeParameterSymbol(firSymbol)
+            is FirCallableSymbol<*> -> callableBuilder.buildCallableSymbol(firSymbol)
+            else -> throwUnexpectedElementError(firSymbol)
         }
     }
 
-    fun buildEnumEntrySymbol(fir: FirEnumEntry) = symbolsCache.cache(fir) { KtFirEnumEntrySymbol(fir, resolveState, token, this) }
+    fun buildEnumEntrySymbol(firSymbol: FirEnumEntrySymbol) =
+        symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, resolveState, token, this) }
 
-    fun buildFileSymbol(fir: FirFile) = filesCache.cache(fir) { KtFirFileSymbol(fir, resolveState, token) }
+    fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, resolveState, token) }
 
     private val packageProvider = project.createPackageProvider(GlobalSearchScope.allScope(project))//todo scope
 
@@ -138,105 +141,105 @@ internal class KtSymbolByFirBuilder private constructor(
 
     inner class ClassifierSymbolBuilder {
         fun buildClassifierSymbol(firSymbol: FirClassifierSymbol<*>): KtClassifierSymbol {
-            return when (val fir = firSymbol.fir) {
+            return when (firSymbol) {
-                is FirClassLikeDeclaration -> classifierBuilder.buildClassLikeSymbol(fir)
+                is FirClassLikeSymbol<*> -> classifierBuilder.buildClassLikeSymbol(firSymbol)
-                is FirTypeParameter -> buildTypeParameterSymbol(fir)
+                is FirTypeParameterSymbol -> buildTypeParameterSymbol(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
 
-        fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol {
+        fun buildClassLikeSymbol(firSymbol: FirClassLikeSymbol<*>): KtClassLikeSymbol {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirClass -> buildClassOrObjectSymbol(fir)
+                is FirClassSymbol<*> -> buildClassOrObjectSymbol(firSymbol)
-                is FirTypeAlias -> buildTypeAliasSymbol(fir)
+                is FirTypeAliasSymbol -> buildTypeAliasSymbol(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
-        fun buildClassOrObjectSymbol(fir: FirClass): KtClassOrObjectSymbol {
+        fun buildClassOrObjectSymbol(firSymbol: FirClassSymbol<*>): KtClassOrObjectSymbol {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirAnonymousObject -> buildAnonymousObjectSymbol(fir)
+                is FirAnonymousObjectSymbol -> buildAnonymousObjectSymbol(firSymbol)
-                is FirRegularClass -> buildNamedClassOrObjectSymbol(fir)
+                is FirRegularClassSymbol -> buildNamedClassOrObjectSymbol(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
-        fun buildNamedClassOrObjectSymbol(fir: FirRegularClass): KtFirNamedClassOrObjectSymbol {
+        fun buildNamedClassOrObjectSymbol(symbol: FirRegularClassSymbol): KtFirNamedClassOrObjectSymbol {
-            return symbolsCache.cache(fir) { KtFirNamedClassOrObjectSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildAnonymousObjectSymbol(fir: FirAnonymousObject): KtAnonymousObjectSymbol {
+        fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
-            return symbolsCache.cache(fir) { KtFirAnonymousObjectSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildTypeAliasSymbol(fir: FirTypeAlias): KtFirTypeAliasSymbol {
+        fun buildTypeAliasSymbol(symbol: FirTypeAliasSymbol): KtFirTypeAliasSymbol {
-            return symbolsCache.cache(fir) { KtFirTypeAliasSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildTypeParameterSymbol(fir: FirTypeParameter): KtFirTypeParameterSymbol {
+        fun buildTypeParameterSymbol(firSymbol: FirTypeParameterSymbol): KtFirTypeParameterSymbol {
-            return symbolsCache.cache(fir) { KtFirTypeParameterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirTypeParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
         fun buildTypeParameterSymbolByLookupTag(lookupTag: ConeTypeParameterLookupTag): KtTypeParameterSymbol? {
             val firTypeParameterSymbol = firProvider.getSymbolByLookupTag(lookupTag) as? FirTypeParameterSymbol ?: return null
-            return buildTypeParameterSymbol(firTypeParameterSymbol.fir)
+            return buildTypeParameterSymbol(firTypeParameterSymbol)
         }
 
         fun buildClassLikeSymbolByClassId(classId: ClassId): KtClassLikeSymbol? {
             val firClassLikeSymbol = firProvider.getClassLikeSymbolByClassId(classId) ?: return null
-            return buildClassLikeSymbol(firClassLikeSymbol.fir)
+            return buildClassLikeSymbol(firClassLikeSymbol)
         }
 
         fun buildClassLikeSymbolByLookupTag(lookupTag: ConeClassLikeLookupTag): KtClassLikeSymbol? {
             val firClassLikeSymbol = firProvider.getSymbolByLookupTag(lookupTag) ?: return null
-            return buildClassLikeSymbol(firClassLikeSymbol.fir)
+            return buildClassLikeSymbol(firClassLikeSymbol)
         }
     }
 
     inner class FunctionLikeSymbolBuilder {
-        fun buildFunctionLikeSymbol(fir: FirFunction): KtFunctionLikeSymbol {
+        fun buildFunctionLikeSymbol(firSymbol: FirFunctionSymbol<*>): KtFunctionLikeSymbol {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirSimpleFunction -> {
+                is FirNamedFunctionSymbol -> {
-                    if (fir.origin == FirDeclarationOrigin.SamConstructor) {
+                    if (firSymbol.origin == FirDeclarationOrigin.SamConstructor) {
-                        buildSamConstructorSymbol(fir)
+                        buildSamConstructorSymbol(firSymbol)
                     } else {
-                        buildFunctionSymbol(fir)
+                        buildFunctionSymbol(firSymbol)
                     }
                 }
-                is FirConstructor -> buildConstructorSymbol(fir)
+                is FirConstructorSymbol -> buildConstructorSymbol(firSymbol)
-                is FirAnonymousFunction -> buildAnonymousFunctionSymbol(fir)
+                is FirAnonymousFunctionSymbol -> buildAnonymousFunctionSymbol(firSymbol)
-                is FirPropertyAccessor -> buildPropertyAccessorSymbol(fir)
+                is FirPropertyAccessorSymbol -> buildPropertyAccessorSymbol(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
-        fun buildFunctionLikeSignature(fir: FirFunction): KtFunctionLikeSignature<KtFunctionLikeSymbol> {
+        fun buildFunctionLikeSignature(fir: FirFunctionSymbol<*>): KtFunctionLikeSignature<KtFunctionLikeSymbol> {
-            if (fir is FirSimpleFunction && fir.origin != FirDeclarationOrigin.SamConstructor)
+            if (fir is FirNamedFunctionSymbol && fir.origin != FirDeclarationOrigin.SamConstructor)
                 return buildFunctionSignature(fir)
             return buildFunctionLikeSymbol(fir).toSignature()
         }
 
-        fun buildFunctionSymbol(fir: FirSimpleFunction): KtFirFunctionSymbol {
+        fun buildFunctionSymbol(firSymbol: FirNamedFunctionSymbol): KtFirFunctionSymbol {
-            fir.unwrapSubstitutionOverrideIfNeeded()?.let {
+            firSymbol.fir.unwrapSubstitutionOverrideIfNeeded()?.let {
-                return buildFunctionSymbol(it)
+                return buildFunctionSymbol(it.symbol)
             }
-            if (fir.dispatchReceiverType?.contains { it is ConeStubType } == true) {
+            if (firSymbol.dispatchReceiverType?.contains { it is ConeStubType } == true) {
-                return buildFunctionSymbol(fir.originalIfFakeOverride() ?: error("Stub type in real declaration"))
+                return buildFunctionSymbol(firSymbol.originalIfFakeOverride() ?: error("Stub type in real declaration"))
             }
 
-            check(fir.origin != FirDeclarationOrigin.SamConstructor)
+            check(firSymbol.origin != FirDeclarationOrigin.SamConstructor)
-            return symbolsCache.cache(fir) { KtFirFunctionSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildFunctionSignature(fir: FirSimpleFunction): KtFunctionLikeSignature<KtFirFunctionSymbol> {
+        fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> {
-            fir.symbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-            val functionSymbol = buildFunctionSymbol(fir)
+            val functionSymbol = buildFunctionSymbol(firSymbol)
             return KtFunctionLikeSignature(
                 functionSymbol,
-                typeBuilder.buildKtType(fir.returnTypeRef),
+                typeBuilder.buildKtType(firSymbol.resolvedReturnType),
-                fir.receiverTypeRef?.let { typeBuilder.buildKtType(it) },
+                firSymbol.resolvedReceiverTypeRef?.let { typeBuilder.buildKtType(it) },
-                functionSymbol.valueParameters.zip(fir.valueParameters).map { (ktSymbol, fir) ->
+                functionSymbol.valueParameters.zip(firSymbol.fir.valueParameters).map { (ktSymbol, fir) ->
                     var type = fir.returnTypeRef.coneType
                     if (fir.isVararg) {
                         type = type.arrayElementType() ?: type
@@ -246,114 +249,118 @@ internal class KtSymbolByFirBuilder private constructor(
             )
         }
 
-        fun buildAnonymousFunctionSymbol(fir: FirAnonymousFunction): KtFirAnonymousFunctionSymbol {
+        fun buildAnonymousFunctionSymbol(firSymbol: FirAnonymousFunctionSymbol): KtFirAnonymousFunctionSymbol {
-            return symbolsCache.cache(fir) { KtFirAnonymousFunctionSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirAnonymousFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildConstructorSymbol(fir: FirConstructor): KtFirConstructorSymbol {
+        fun buildConstructorSymbol(firSymbol: FirConstructorSymbol): KtFirConstructorSymbol {
-            val originalFir = fir.originalConstructorIfTypeAlias ?: fir
+            val originalFirSymbol = firSymbol.fir.originalConstructorIfTypeAlias?.symbol ?: firSymbol
-            return symbolsCache.cache(originalFir) {
+            return symbolsCache.cache(originalFirSymbol) {
-                KtFirConstructorSymbol(originalFir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirConstructorSymbol(originalFirSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
-        fun buildSamConstructorSymbol(fir: FirSimpleFunction): KtFirSamConstructorSymbol {
+        fun buildSamConstructorSymbol(firSymbol: FirNamedFunctionSymbol): KtFirSamConstructorSymbol {
-            check(fir.origin == FirDeclarationOrigin.SamConstructor)
+            check(firSymbol.origin == FirDeclarationOrigin.SamConstructor)
-            return symbolsCache.cache(fir) { KtFirSamConstructorSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirSamConstructorSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildPropertyAccessorSymbol(fir: FirPropertyAccessor): KtFunctionLikeSymbol {
+        fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtFunctionLikeSymbol {
-            return symbolsCache.cache(fir) {
+            return symbolsCache.cache(firSymbol) {
-                if (fir.isGetter) {
+                if (firSymbol.isGetter) {
-                    KtFirPropertyGetterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
                 } else {
-                    KtFirPropertySetterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
                 }
             }
         }
     }
 
     inner class VariableLikeSymbolBuilder {
-        fun buildVariableLikeSymbol(fir: FirVariable): KtVariableLikeSymbol {
+        fun buildVariableLikeSymbol(firSymbol: FirVariableSymbol<*>): KtVariableLikeSymbol {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirProperty -> buildVariableSymbol(fir)
+                is FirPropertySymbol -> buildVariableSymbol(firSymbol)
-                is FirValueParameter -> buildValueParameterSymbol(fir)
+                is FirValueParameterSymbol -> buildValueParameterSymbol(firSymbol)
-                is FirField -> buildFieldSymbol(fir)
+                is FirFieldSymbol -> buildFieldSymbol(firSymbol)
-                is FirEnumEntry -> buildEnumEntrySymbol(fir) // TODO enum entry should not be callable
+                is FirEnumEntrySymbol -> buildEnumEntrySymbol(firSymbol) // TODO enum entry should not be callable
-                is FirBackingField -> buildBackingFieldSymbol(fir)
+                is FirBackingFieldSymbol -> buildBackingFieldSymbol(firSymbol)
 
-                is FirErrorProperty -> throwUnexpectedElementError(fir)
+                is FirErrorPropertySymbol -> throwUnexpectedElementError(firSymbol)
+                is FirDelegateFieldSymbol -> throwUnexpectedElementError(firSymbol)
             }
         }
 
-        fun buildVariableLikeSignature(fir: FirVariable): KtVariableLikeSignature<KtVariableLikeSymbol> {
+        fun buildVariableLikeSignature(firSymbol: FirVariableSymbol<*>): KtVariableLikeSignature<KtVariableLikeSymbol> {
-            if (fir is FirProperty && !fir.isLocal && fir !is FirSyntheticProperty) return buildPropertySignature(fir)
+            if (firSymbol is FirPropertySymbol && !firSymbol.isLocal && firSymbol !is FirSyntheticPropertySymbol) {
-            return buildVariableLikeSymbol(fir).toSignature()
+                return buildPropertySignature(firSymbol)
+            }
+            return buildVariableLikeSymbol(firSymbol).toSignature()
         }
 
-        fun buildVariableSymbol(fir: FirProperty): KtVariableSymbol {
+        fun buildVariableSymbol(firSymbol: FirPropertySymbol): KtVariableSymbol {
             return when {
-                fir.isLocal -> buildLocalVariableSymbol(fir)
+                firSymbol.isLocal -> buildLocalVariableSymbol(firSymbol)
-                fir is FirSyntheticProperty -> buildSyntheticJavaPropertySymbol(fir)
+                firSymbol is FirSyntheticPropertySymbol -> buildSyntheticJavaPropertySymbol(firSymbol)
-                else -> buildPropertySymbol(fir)
+                else -> buildPropertySymbol(firSymbol)
             }
         }
 
-        fun buildPropertySymbol(fir: FirProperty): KtVariableSymbol {
+        fun buildPropertySymbol(firSymbol: FirPropertySymbol): KtVariableSymbol {
-            checkRequirementForBuildingSymbol<KtKotlinPropertySymbol>(fir, !fir.isLocal)
+            checkRequirementForBuildingSymbol<KtKotlinPropertySymbol>(firSymbol, !firSymbol.isLocal)
-            checkRequirementForBuildingSymbol<KtKotlinPropertySymbol>(fir, fir !is FirSyntheticProperty)
+            checkRequirementForBuildingSymbol<KtKotlinPropertySymbol>(firSymbol, firSymbol !is FirSyntheticPropertySymbol)
+            checkRequirementForBuildingSymbol<KtKotlinPropertySymbol>(firSymbol, firSymbol !is FirSyntheticPropertySymbol)
 
-            fir.unwrapSubstitutionOverrideIfNeeded()?.let {
+            firSymbol.fir.unwrapSubstitutionOverrideIfNeeded()?.let {
-                return buildVariableSymbol(it)
+                return buildVariableSymbol(it.symbol)
             }
 
-            return symbolsCache.cache(fir) {
+            return symbolsCache.cache(firSymbol) {
-                KtFirKotlinPropertySymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirKotlinPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
-        fun buildPropertySignature(fir: FirProperty): KtVariableLikeSignature<KtVariableSymbol> {
+        fun buildPropertySignature(firSymbol: FirPropertySymbol): KtVariableLikeSignature<KtVariableSymbol> {
-            fir.symbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
             return KtVariableLikeSignature(
-                buildPropertySymbol(fir),
+                buildPropertySymbol(firSymbol),
-                typeBuilder.buildKtType(fir.returnTypeRef),
+                typeBuilder.buildKtType(firSymbol.fir.returnTypeRef),
-                fir.receiverTypeRef?.let { typeBuilder.buildKtType(it) }
+                firSymbol.resolvedReceiverTypeRef?.let { typeBuilder.buildKtType(it) }
             )
         }
 
-        fun buildLocalVariableSymbol(fir: FirProperty): KtFirLocalVariableSymbol {
+        fun buildLocalVariableSymbol(firSymbol: FirPropertySymbol): KtFirLocalVariableSymbol {
-            checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(fir, fir.isLocal)
+            checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(firSymbol, firSymbol.isLocal)
-            return symbolsCache.cache(fir) {
+            return symbolsCache.cache(firSymbol) {
-                KtFirLocalVariableSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirLocalVariableSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
-        fun buildSyntheticJavaPropertySymbol(fir: FirSyntheticProperty): KtFirSyntheticJavaPropertySymbol {
+        fun buildSyntheticJavaPropertySymbol(firSymbol: FirSyntheticPropertySymbol): KtFirSyntheticJavaPropertySymbol {
-            return symbolsCache.cache(fir) {
+            return symbolsCache.cache(firSymbol) {
-                KtFirSyntheticJavaPropertySymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirSyntheticJavaPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
-        fun buildValueParameterSymbol(fir: FirValueParameter): KtValueParameterSymbol {
+        fun buildValueParameterSymbol(firSymbol: FirValueParameterSymbol): KtValueParameterSymbol {
-            return symbolsCache.cache(fir) {
+            return symbolsCache.cache(firSymbol) {
-                KtFirValueParameterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirValueParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
 
-        fun buildFieldSymbol(fir: FirField): KtFirJavaFieldSymbol {
+        fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol {
-            checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(fir, fir.isJavaFieldOrSubstitutionOverrideOfJavaField())
+            checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(firSymbol, firSymbol.fir.isJavaFieldOrSubstitutionOverrideOfJavaField())
-            return symbolsCache.cache(fir) { KtFirJavaFieldSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildBackingFieldSymbol(fir: FirBackingField): KtFirBackingFieldSymbol {
+        fun buildBackingFieldSymbol(firSymbol: FirBackingFieldSymbol): KtFirBackingFieldSymbol {
-            return backingFieldCache.cache(fir) {
+            return backingFieldCache.cache(firSymbol) {
-                KtFirBackingFieldSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirBackingFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
 
-        fun buildBackingFieldSymbolByProperty(fir: FirProperty): KtFirBackingFieldSymbol {
+        fun buildBackingFieldSymbolByProperty(firSymbol: FirPropertySymbol): KtFirBackingFieldSymbol {
-            val backingFieldSymbol = fir.backingField
+            val backingFieldSymbol = firSymbol.backingFieldSymbol
                 ?: error("FirProperty backingField is null")
             return buildBackingFieldSymbol(backingFieldSymbol)
         }
@@ -366,53 +373,53 @@ internal class KtSymbolByFirBuilder private constructor(
     }
 
     inner class CallableSymbolBuilder {
-        fun buildCallableSymbol(fir: FirCallableDeclaration): KtCallableSymbol {
+        fun buildCallableSymbol(firSymbol: FirCallableSymbol<*>): KtCallableSymbol {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirPropertyAccessor -> buildPropertyAccessorSymbol(fir)
+                is FirPropertyAccessorSymbol -> buildPropertyAccessorSymbol(firSymbol)
-                is FirFunction -> functionLikeBuilder.buildFunctionLikeSymbol(fir)
+                is FirFunctionSymbol<*> -> functionLikeBuilder.buildFunctionLikeSymbol(firSymbol)
-                is FirVariable -> variableLikeBuilder.buildVariableLikeSymbol(fir)
+                is FirVariableSymbol<*> -> variableLikeBuilder.buildVariableLikeSymbol(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
-        fun buildCallableSignature(fir: FirCallableDeclaration): KtSignature<KtCallableSymbol> {
+        fun buildCallableSignature(firSymbol: FirCallableSymbol<*>): KtSignature<KtCallableSymbol> {
-            return when (fir) {
+            return when (firSymbol) {
-                is FirPropertyAccessor -> buildPropertyAccessorSymbol(fir).toSignature()
+                is FirPropertyAccessorSymbol -> buildPropertyAccessorSymbol(firSymbol).toSignature()
-                is FirFunction -> functionLikeBuilder.buildFunctionLikeSignature(fir)
+                is FirFunctionSymbol<*> -> functionLikeBuilder.buildFunctionLikeSignature(firSymbol)
-                is FirVariable -> variableLikeBuilder.buildVariableLikeSignature(fir)
+                is FirVariableSymbol<*> -> variableLikeBuilder.buildVariableLikeSignature(firSymbol)
-                else -> throwUnexpectedElementError(fir)
+                else -> throwUnexpectedElementError(firSymbol)
             }
         }
 
 
-        fun buildPropertyAccessorSymbol(fir: FirPropertyAccessor): KtPropertyAccessorSymbol {
+        fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtPropertyAccessorSymbol {
             return when {
-                fir.isGetter -> buildGetterSymbol(fir)
+                firSymbol.isGetter -> buildGetterSymbol(firSymbol)
-                else -> buildSetterSymbol(fir)
+                else -> buildSetterSymbol(firSymbol)
             }
         }
 
-        fun buildGetterSymbol(fir: FirPropertyAccessor): KtFirPropertyGetterSymbol {
+        fun buildGetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertyGetterSymbol {
-            checkRequirementForBuildingSymbol<KtFirPropertyGetterSymbol>(fir, fir.isGetter)
+            checkRequirementForBuildingSymbol<KtFirPropertyGetterSymbol>(firSymbol, firSymbol.isGetter)
-            return symbolsCache.cache(fir) { KtFirPropertyGetterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildSetterSymbol(fir: FirPropertyAccessor): KtFirPropertySetterSymbol {
+        fun buildSetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertySetterSymbol {
-            checkRequirementForBuildingSymbol<KtFirPropertySetterSymbol>(fir, fir.isSetter)
+            checkRequirementForBuildingSymbol<KtFirPropertySetterSymbol>(firSymbol, firSymbol.isSetter)
-            return symbolsCache.cache(fir) { KtFirPropertySetterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) }
         }
 
-        fun buildExtensionReceiverSymbol(fir: FirCallableDeclaration): KtReceiverParameterSymbol? {
+        fun buildExtensionReceiverSymbol(firCallableSymbol: FirCallableSymbol<*>): KtReceiverParameterSymbol? {
-            if (fir.receiverTypeRef == null) return null
+            if (firCallableSymbol.fir.receiverTypeRef == null) return null
-            return extensionReceiverSymbolsCache.cache(fir) {
+            return extensionReceiverSymbolsCache.cache(firCallableSymbol) {
-                KtFirReceiverParameterSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder)
+                KtFirReceiverParameterSymbol(firCallableSymbol, resolveState, token, this@KtSymbolByFirBuilder)
             }
         }
     }
 
     inner class AnonymousInitializerBuilder {
-        fun buildClassInitializer(fir: FirAnonymousInitializer): KtClassInitializerSymbol {
+        fun buildClassInitializer(firSymbol: FirAnonymousInitializerSymbol): KtClassInitializerSymbol {
-            return symbolsCache.cache(fir) { KtFirClassInitializerSymbol(fir, resolveState, token) }
+            return symbolsCache.cache(firSymbol) { KtFirClassInitializerSymbol(firSymbol, resolveState, token) }
         }
     }
 
@@ -516,14 +523,14 @@ internal class KtSymbolByFirBuilder private constructor(
 
         @OptIn(ExperimentalContracts::class)
         private inline fun <reified S : KtSymbol> checkRequirementForBuildingSymbol(
-            fir: FirElement,
+            firSymbol: FirBasedSymbol<*>,
             requirement: Boolean,
         ) {
             contract {
                 returns() implies requirement
             }
             require(requirement) {
-                "Cannot build ${S::class.simpleName} for ${fir.renderWithType(FirRenderer.RenderMode.WithResolvePhases)}"
+                "Cannot build ${S::class.simpleName} for ${firSymbol.fir.renderWithType(FirRenderer.RenderMode.WithResolvePhases)}"
             }
         }
     }
@@ -551,10 +558,10 @@ private class BuilderCache<From, To : Any> private constructor(
 }
 
 internal fun FirElement.buildSymbol(builder: KtSymbolByFirBuilder) =
-    (this as? FirDeclaration)?.let(builder::buildSymbol)
+    (this as? FirDeclaration)?.symbol?.let(builder::buildSymbol)
 
 internal fun FirDeclaration.buildSymbol(builder: KtSymbolByFirBuilder) =
-    builder.buildSymbol(this)
+    builder.buildSymbol(symbol)
 
 private fun collectReferencedTypeParameters(declaration: FirCallableDeclaration): Set<ConeTypeParameterLookupTag> {
     val allUsedTypeParameters = mutableSetOf<ConeTypeParameterLookupTag>()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/annotations/KtFirAnnotationListForDeclaration.kt

@@ -8,56 +8,52 @@ package org.jetbrains.kotlin.analysis.api.fir.annotations
 import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
 import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.fir.toKtAnnotationApplication
-import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
 import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirAnnotationListForDeclaration private constructor(
-    val firRef: FirRefWithValidityCheck<*>,
+    val firSymbol: FirBasedSymbol<*>,
     private val useSiteSession: FirSession,
     override val token: ValidityToken,
 ) : KtAnnotationsList() {
     override val annotations: List<KtAnnotationApplication>
-        get() = firRef.withFir(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) { fir ->
+        get() = withValidityAssertion {
-            fir.annotations.map { annotation ->
+            firSymbol.resolvedAnnotationsWithArguments
-                annotation.toKtAnnotationApplication(useSiteSession)
+                .map { annotation ->
-            }
+                    annotation.toKtAnnotationApplication(useSiteSession)
+                }
         }
 
 
-    override fun containsAnnotation(classId: ClassId): Boolean {
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-        return firRef.withFirByType(ResolveType.AnnotationType) { fir ->
+        firSymbol.resolvedAnnotationClassIds.contains(classId)
-            fir.annotations.any { it.fullyExpandedClassId(useSiteSession) == classId }
+    }
+
+    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> = withValidityAssertion {
+        firSymbol.resolvedAnnotationsWithArguments.mapNotNull { annotation ->
+            if (annotation.fullyExpandedClassId(useSiteSession) != classId) return@mapNotNull null
+            annotation.toKtAnnotationApplication(useSiteSession)
         }
     }
 
-    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> =
-        firRef.withFir(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) { fir ->
-            fir.annotations.mapNotNull { annotation ->
-                if (annotation.fullyExpandedClassId(useSiteSession) != classId) return@mapNotNull null
-                annotation.toKtAnnotationApplication(useSiteSession)
-            }
-        }
 
     override val annotationClassIds: Collection<ClassId>
-        get() = firRef.withFirByType(ResolveType.AnnotationType) { fir ->
+        get() = withValidityAssertion { firSymbol.resolvedAnnotationClassIds }
-            fir.annotations.mapNotNull { it.fullyExpandedClassId(useSiteSession) }
-        }
 
     companion object {
         fun create(
-            firRef: FirRefWithValidityCheck<*>,
+            firSymbol: FirBasedSymbol<*>,
             useSiteSession: FirSession,
             token: ValidityToken,
         ): KtAnnotationsList {
-            return if (firRef.withFir { it.annotations.isEmpty() }) {
+            return if (firSymbol.annotations.isEmpty()) {
                 KtEmptyAnnotationsList(token)
             } else {
-                KtFirAnnotationListForDeclaration(firRef, useSiteSession, token)
+                KtFirAnnotationListForDeclaration(firSymbol, useSiteSession, token)
             }
         }
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt

@@ -592,7 +592,7 @@ internal class KtFirCallResolver(
                 if (psi == null) {
                     val implicitPartiallyAppliedSymbol = when (val partiallyAppliedSymbol = calleeReference.boundSymbol) {
                         is FirClassSymbol<*> -> partiallyAppliedSymbol.toKtSymbol()
-                        is FirCallableSymbol<*> -> firSymbolBuilder.callableBuilder.buildExtensionReceiverSymbol(partiallyAppliedSymbol.fir)
+                        is FirCallableSymbol<*> -> firSymbolBuilder.callableBuilder.buildExtensionReceiverSymbol(partiallyAppliedSymbol)
                             ?: return null
                         else -> return null
                     }
@@ -611,22 +611,22 @@ internal class KtFirCallResolver(
 
     @OptIn(SymbolInternals::class)
     private fun FirCallableSymbol<*>.toKtSignature(): KtSignature<KtCallableSymbol> =
-        firSymbolBuilder.callableBuilder.buildCallableSignature(fir)
+        firSymbolBuilder.callableBuilder.buildCallableSignature(this)
 
     @OptIn(SymbolInternals::class)
-    private fun FirClassLikeSymbol<*>.toKtSymbol(): KtClassLikeSymbol = firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir)
+    private fun FirClassLikeSymbol<*>.toKtSymbol(): KtClassLikeSymbol = firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(this)
 
     @OptIn(SymbolInternals::class)
     private fun FirNamedFunctionSymbol.toKtSignature(): KtFunctionLikeSignature<KtFunctionSymbol> =
-        firSymbolBuilder.functionLikeBuilder.buildFunctionSignature(fir)
+        firSymbolBuilder.functionLikeBuilder.buildFunctionSignature(this)
 
     @OptIn(SymbolInternals::class)
     private fun FirVariableSymbol<*>.toKtSignature(): KtVariableLikeSignature<KtVariableLikeSymbol> =
-        firSymbolBuilder.variableLikeBuilder.buildVariableLikeSignature(fir)
+        firSymbolBuilder.variableLikeBuilder.buildVariableLikeSignature(this)
 
     @OptIn(SymbolInternals::class)
     private fun FirValueParameterSymbol.toKtSymbol(): KtValueParameterSymbol =
-        firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(fir)
+        firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(this)
 
     private fun FirArrayOfCall.toKtCallInfo(): KtCallInfo? {
         val arrayOfSymbol = with(analysisSession) {
@@ -668,15 +668,15 @@ internal class KtFirCallResolver(
     }
 
     private fun FirArrayOfCall.createSubstitutorFromTypeArguments(arrayOfSymbol: KtFirFunctionSymbol): KtSubstitutor {
-        return arrayOfSymbol.firRef.withFir {
+        val firSymbol = arrayOfSymbol.firSymbol
-            // No type parameter means this is an arrayOf call of primitives, in which case there is no type arguments
+        // No type parameter means this is an arrayOf call of primitives, in which case there is no type arguments
-            val typeParameter = it.typeParameters.singleOrNull() ?: return@withFir null
+        val typeParameter = firSymbol.fir.typeParameters.singleOrNull() ?: return KtSubstitutor.Empty(token)
-            val elementType = typeRef.coneTypeSafe<ConeClassLikeType>()?.arrayElementType() ?: return@withFir null
+        val elementType = typeRef.coneTypeSafe<ConeClassLikeType>()?.arrayElementType() ?: return KtSubstitutor.Empty(token)
-            val coneSubstitutor = substitutorByMap(mapOf(typeParameter.symbol to elementType), rootModuleSession)
+        val coneSubstitutor = substitutorByMap(mapOf(typeParameter.symbol to elementType), rootModuleSession)
-            firSymbolBuilder.typeBuilder.buildSubstitutor(coneSubstitutor)
+        return firSymbolBuilder.typeBuilder.buildSubstitutor(coneSubstitutor)
-        } ?: KtSubstitutor.Empty(token)
     }
 
+
     private fun FirEqualityOperatorCall.toKtCallInfo(psi: KtElement): KtCallInfo? {
         val binaryExpression = deparenthesize(psi as? KtExpression) as? KtBinaryExpression ?: return null
         val leftPsi = binaryExpression.left ?: return null
@@ -748,9 +748,8 @@ internal class KtFirCallResolver(
         substitutor: KtSubstitutor,
     ): LinkedHashMap<KtExpression, KtVariableLikeSignature<KtValueParameterSymbol>> {
         val ktArgumentMapping = LinkedHashMap<KtExpression, KtVariableLikeSignature<KtValueParameterSymbol>>()
-        val parameterSymbol = arrayOfCallSymbol.firRef.withFir {
+        val parameterSymbol = arrayOfCallSymbol.firSymbol.fir.valueParameters.single().symbol.toKtSymbol()
-            it.valueParameters.single().symbol.toKtSymbol()
+
-        }
         for (firExpression in argumentList.arguments) {
             mapArgumentExpressionToParameter(firExpression, parameterSymbol.toSignature(substitutor), ktArgumentMapping)
         }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt

@@ -26,8 +26,9 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
-import org.jetbrains.kotlin.fir.types.receiverType
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.receiverType
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
@@ -45,12 +46,10 @@ internal class KtFirCompletionCandidateChecker(
         possibleExplicitReceiver: KtExpression?,
     ): KtExtensionApplicabilityResult = withValidityAssertion {
         require(firSymbolForCandidate is KtFirSymbol<*>)
-        return firSymbolForCandidate.firRef.withFir(
+        firSymbolForCandidate.firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-            phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE
+        val declaration = firSymbolForCandidate.firSymbol.fir as FirCallableDeclaration
-        ) { declaration ->
+        checkExtension(declaration, originalFile, nameExpression, possibleExplicitReceiver)
-            check(declaration is FirCallableDeclaration)
+
-            checkExtension(declaration, originalFile, nameExpression, possibleExplicitReceiver)
-        }
     }
 
     private fun checkExtension(

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionInfoProvider.kt

@@ -5,16 +5,16 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
-import org.jetbrains.kotlin.diagnostics.WhenMissingCase
-import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
-import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
 import org.jetbrains.kotlin.analysis.api.components.KtExpressionInfoProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
+import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
+import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
+import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
+import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
 import org.jetbrains.kotlin.psi.KtReturnExpression
 import org.jetbrains.kotlin.psi.KtWhenExpression
 
@@ -26,7 +26,7 @@ internal class KtFirExpressionInfoProvider(
         val fir = returnExpression.getOrBuildFirSafe<FirReturnExpression>(firResolveState) ?: return null
         val firTargetSymbol = fir.target.labeledElement
         if (firTargetSymbol is FirErrorFunction) return null
-        return firSymbolBuilder.callableBuilder.buildCallableSymbol(firTargetSymbol)
+        return firSymbolBuilder.callableBuilder.buildCallableSymbol(firTargetSymbol.symbol)
     }
 
     override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirInheritorsProvider.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors
 import org.jetbrains.kotlin.analysis.api.components.KtInheritorsProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirNamedClassOrObjectSymbol
@@ -15,6 +13,8 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors
 
 internal class KtFirInheritorsProvider(
     override val analysisSession: KtFirAnalysisSession,
@@ -26,9 +26,7 @@ internal class KtFirInheritorsProvider(
         require(classSymbol.modality == Modality.SEALED)
         require(classSymbol is KtFirNamedClassOrObjectSymbol)
 
-        val inheritorClassIds = classSymbol.firRef.withFir { fir ->
+        val inheritorClassIds = classSymbol.firSymbol.fir.getSealedClassInheritors(analysisSession.rootModuleSession)
-            fir.getSealedClassInheritors(analysisSession.rootModuleSession)
-        }
 
         with(analysisSession) {
             inheritorClassIds.mapNotNull { it.getCorrespondingToplevelClassOrObjectSymbol() as? KtNamedClassOrObjectSymbol }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt

@@ -88,8 +88,8 @@ internal class KtFirReferenceShortener(
             context,
             towerContext,
             selection,
-            classShortenOption = { classShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it.fir) as KtClassLikeSymbol) },
+            classShortenOption = { classShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtClassLikeSymbol) },
-            callableShortenOption = { callableShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it.fir) as KtCallableSymbol) },
+            callableShortenOption = { callableShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtCallableSymbol) },
             firResolveState,
         )
         firDeclaration.accept(collector)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSamResolver.kt

@@ -5,6 +5,12 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
+import org.jetbrains.kotlin.analysis.api.components.KtSamResolver
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.getClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
@@ -13,12 +19,6 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer
-import org.jetbrains.kotlin.analysis.api.components.KtSamResolver
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.getClassLikeSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 
 internal class KtFirSamResolver(
     override val analysisSession: KtFirAnalysisSession,
@@ -30,7 +30,7 @@ internal class KtFirSamResolver(
         val owner = analysisSession.getClassLikeSymbol(classId) as? FirRegularClass ?: return null
         val resolver = LocalSamResolver(analysisSession.rootModuleSession)
         return resolver.getSamConstructor(owner)?.let {
-            analysisSession.firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(it)
+            analysisSession.firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(it.symbol)
         }
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt

@@ -7,18 +7,6 @@ package org.jetbrains.kotlin.analysis.api.fir.components
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
-import org.jetbrains.kotlin.fir.resolve.scope
-import org.jetbrains.kotlin.fir.scopes.*
-import org.jetbrains.kotlin.fir.scopes.impl.*
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir.getTowerContextProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.components.KtImplicitReceiver
 import org.jetbrains.kotlin.analysis.api.components.KtScopeContext
@@ -26,19 +14,35 @@ import org.jetbrains.kotlin.analysis.api.components.KtScopeProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.scopes.*
-import org.jetbrains.kotlin.analysis.api.fir.symbols.*
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirAnonymousObjectSymbol
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirEnumEntrySymbol
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType
 import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
-import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtEmptyScope
 import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtCompositeScope
-import org.jetbrains.kotlin.analysis.api.scopes.*
+import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtEmptyScope
+import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir.getTowerContextProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.utils.delegateFields
+import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
+import org.jetbrains.kotlin.fir.resolve.scope
+import org.jetbrains.kotlin.fir.scopes.*
+import org.jetbrains.kotlin.fir.scopes.impl.*
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import java.util.*
@@ -60,15 +64,24 @@ internal class KtFirScopeProvider(
     private val fileScopeCache = IdentityHashMap<KtFileSymbol, KtScope>()
     private val packageMemberScopeCache = IdentityHashMap<KtPackageSymbol, KtScope>()
 
-    private inline fun <T> KtSymbolWithMembers.withFirForScope(crossinline body: (FirClass) -> T): T? = when (this) {
+    private inline fun <T> KtSymbolWithMembers.withFirForScope(crossinline body: (FirClass) -> T): T? {
-        is KtFirNamedClassOrObjectSymbol -> firRef.withFir(FirResolvePhase.TYPES, body)
+        when (this) {
-        is KtFirAnonymousObjectSymbol -> firRef.withFir(FirResolvePhase.TYPES, body)
+            is KtFirNamedClassOrObjectSymbol -> {
-        is KtFirEnumEntrySymbol -> firRef.withFir(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
+                firSymbol.ensureResolved(FirResolvePhase.TYPES)
-            val initializer = it.initializer
+                return body(firSymbol.fir)
-            check(initializer is FirAnonymousObjectExpression) { "Unexpected enum entry initializer: ${initializer?.javaClass}" }
+            }
-            body(initializer.anonymousObject)
+            is KtFirAnonymousObjectSymbol -> {
+                firSymbol.ensureResolved(FirResolvePhase.TYPES)
+                return body(firSymbol.fir)
+            }
+            is KtFirEnumEntrySymbol -> {
+                firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+                val initializer = firSymbol.fir.initializer
+                check(initializer is FirAnonymousObjectExpression) { "Unexpected enum entry initializer: ${initializer?.javaClass}" }
+                return body(initializer.anonymousObject)
+            }
+            else -> error { "Unknown KtSymbolWithDeclarations implementation ${this::class.qualifiedName}" }
         }
-        else -> error { "Unknown KtSymbolWithDeclarations implementation ${this::class.qualifiedName}" }
     }
 
     override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt

@@ -19,13 +19,8 @@ import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.psi
-import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtDestructuringDeclaration
-import org.jetbrains.kotlin.psi.KtFunctionLiteral
-import org.jetbrains.kotlin.psi.KtPrimaryConstructor
-import org.jetbrains.kotlin.psi.KtProperty
 
 internal class KtFirSymbolContainingDeclarationProvider(
     override val analysisSession: KtFirAnalysisSession,
@@ -35,10 +30,9 @@ internal class KtFirSymbolContainingDeclarationProvider(
         assertIsValidAndAccessible()
 
         if (symbol is KtReceiverParameterSymbol) {
-            return (symbol as KtFirReceiverParameterSymbol).firRef.withFir {
+            return firSymbolBuilder.buildSymbol((symbol as KtFirReceiverParameterSymbol).firSymbol) as KtSymbolWithKind
-                firSymbolBuilder.buildSymbol(it) as KtSymbolWithKind
-            }
         }
+
         if (symbol is KtPackageSymbol) return null
         if (symbol is KtSymbolWithKind && symbol.symbolKind == KtSymbolKind.TOP_LEVEL) return null
         if (symbol is KtCallableSymbol) {
@@ -51,11 +45,10 @@ internal class KtFirSymbolContainingDeclarationProvider(
         }
         return when (symbol) {
             is KtFirTypeParameterSymbol -> {
-                symbol.firRef.withFir { fir ->
+                symbol.firSymbol.containingDeclarationSymbol?.let { containingDeclaration ->
-                    fir.containingDeclarationSymbol?.fir?.let { containingDeclaration ->
+                    firSymbolBuilder.buildSymbol(containingDeclaration) as KtSymbolWithKind
-                        firSymbolBuilder.buildSymbol(containingDeclaration) as KtSymbolWithKind
-                    }
                 }
+
             }
             is KtSymbolWithKind -> when (symbol.origin) {
                 KtSymbolOrigin.SOURCE, KtSymbolOrigin.SOURCE_MEMBER_GENERATED ->
@@ -90,7 +83,7 @@ internal class KtFirSymbolContainingDeclarationProvider(
     }
 
     private fun getContainingPsi(symbol: KtFirSymbol<*>): KtDeclaration {
-        val source = symbol.firRef.withFir(action = FirDeclaration::source)
+        val source = symbol.firSymbol.source
         val thisSource = when (source?.kind) {
             null -> error("PSI should present for declaration built by Kotlin code")
             KtFakeSourceElementKind.ImplicitConstructor ->

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
@@ -25,6 +24,7 @@ import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverrideFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverridePropertySymbol
 
@@ -43,7 +43,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
                 overriddenDeclaration.symbol.collectIntersectionOverridesSymbolsTo(overriddenElement)
             }
         }
-        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it.fir) }
+        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
     }
 
     override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
@@ -54,7 +54,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
                 overriddenDeclaration.symbol.collectIntersectionOverridesSymbolsTo(overriddenElement)
             }
         }
-        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it.fir) }
+        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
     }
 
     private fun FirTypeScope.processCallableByName(declaration: FirDeclaration) = when (declaration) {
@@ -109,21 +109,21 @@ internal class KtFirSymbolDeclarationOverridesProvider(
     }
 
     private inline fun processOverrides(
-        containingDeclaration: KtFirSymbol<FirClass>,
+        containingDeclaration: KtFirSymbol<FirClassSymbol<*>>,
         callableSymbol: KtFirSymbol<*>,
         crossinline process: (FirTypeScope, FirDeclaration) -> Unit
     ) {
-        containingDeclaration.firRef.withFir(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { firContainer ->
+        containingDeclaration.firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-            callableSymbol.firRef.withFirUnsafe { firCallableDeclaration ->
+        val firContainer = containingDeclaration.firSymbol.fir
-                val firTypeScope = firContainer.unsubstitutedScope(
+        val firCallableDeclaration = callableSymbol.firSymbol.fir
-                    firContainer.moduleData.session,
+
-                    ScopeSession(),
+        val firTypeScope = firContainer.unsubstitutedScope(
-                    withForcedTypeCalculator = false
+            firContainer.moduleData.session,
-                )
+            ScopeSession(),
-                firTypeScope.processCallableByName(firCallableDeclaration)
+            withForcedTypeCalculator = false
-                process(firTypeScope, firCallableDeclaration)
+        )
-            }
+        firTypeScope.processCallableByName(firCallableDeclaration)
-        }
+        process(firTypeScope, firCallableDeclaration)
     }
 
     private fun FirCallableSymbol<*>.collectIntersectionOverridesSymbolsTo(to: MutableCollection<FirCallableSymbol<*>>) {
@@ -153,13 +153,14 @@ internal class KtFirSymbolDeclarationOverridesProvider(
         require(superClass is KtFirSymbol<*>)
 
         if (subClass == superClass) return false
-        return subClass.firRef.withFirByType(ResolveType.ClassSuperTypes) { subClassFir ->
+        subClass.firSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
-            check(subClassFir is FirClass)
+        return isSubClassOf(
-            superClass.firRef.withFir { superClassFir ->
+            subClass = subClass.firSymbol.fir as FirClass,
-                check(superClassFir is FirClass)
+            superClass = superClass.firSymbol.fir as FirClass,
-                isSubClassOf(subClassFir, superClassFir, checkDeep)
+            checkDeep
-            }
+        )
-        }
+
+
     }
 
     private fun isSubClassOf(subClass: FirClass, superClass: FirClass, checkDeep: Boolean): Boolean {
@@ -176,11 +177,10 @@ internal class KtFirSymbolDeclarationOverridesProvider(
     override fun getIntersectionOverriddenSymbols(symbol: KtCallableSymbol): Collection<KtCallableSymbol> {
         require(symbol is KtFirSymbol<*>)
         if (symbol.origin != KtSymbolOrigin.INTERSECTION_OVERRIDE) return emptyList()
-        return symbol.firRef.withFir { fir ->
+        return symbol.firSymbol
-            val firSymbol = fir.symbol
+            .getIntersectionOverriddenSymbols()
-            firSymbol.getIntersectionOverriddenSymbols()
+            .map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
-                .map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it.fir) }
+
-        }
     }
 
     private fun FirBasedSymbol<*>.getIntersectionOverriddenSymbols(): Collection<FirCallableSymbol<*>> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 
 internal class KtFirSymbolDeclarationRendererProvider(
     override val analysisSession: KtFirAnalysisSession,
@@ -30,8 +31,7 @@ internal class KtFirSymbolDeclarationRendererProvider(
 
     override fun renderDeclaration(symbol: KtDeclarationSymbol, options: KtDeclarationRendererOptions): String {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir(FirResolvePhase.BODY_RESOLVE) { fir ->
+        symbol.firSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
-            FirIdeRenderer.render(fir, options, fir.moduleData.session)
+        return FirIdeRenderer.render(symbol.firSymbol.fir, options, symbol.firSymbol.fir.moduleData.session)
-        }
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt

@@ -5,12 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
-import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.getDeprecationForCallSite
-import org.jetbrains.kotlin.fir.declarations.getJvmNameFromAnnotation
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolInfoProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirBackingFieldSymbol
@@ -20,8 +14,14 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSyntheticJavaPropertyS
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.getDeprecationForCallSite
+import org.jetbrains.kotlin.fir.declarations.getJvmNameFromAnnotation
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
 
 internal class KtFirSymbolInfoProvider(
     override val analysisSession: KtFirAnalysisSession,
@@ -30,48 +30,45 @@ internal class KtFirSymbolInfoProvider(
     override fun getDeprecation(symbol: KtSymbol): DeprecationInfo? {
         if (symbol is KtFirBackingFieldSymbol || symbol is KtFirPackageSymbol) return null
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir {
+        return when (val firSymbol = symbol.firSymbol) {
-            val firSymbol = it.symbol
+            is FirPropertySymbol -> {
-            if (firSymbol is FirPropertySymbol) {
                 firSymbol.getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY)
-            } else {
+            }
+            else -> {
                 firSymbol.getDeprecationForCallSite()
             }
         }
+
     }
 
     override fun getDeprecation(symbol: KtSymbol, annotationUseSiteTarget: AnnotationUseSiteTarget?): DeprecationInfo? {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir { firDeclaration ->
+        return if (annotationUseSiteTarget != null) {
-            if (annotationUseSiteTarget != null) {
+            symbol.firSymbol.getDeprecationForCallSite(annotationUseSiteTarget)
-                firDeclaration.symbol.getDeprecationForCallSite(annotationUseSiteTarget)
+        } else {
-            } else {
+            symbol.firSymbol.getDeprecationForCallSite()
-                firDeclaration.symbol.getDeprecationForCallSite()
-            }
         }
+
     }
 
     override fun getGetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir {
+        return symbol.firSymbol.getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_GETTER, AnnotationUseSiteTarget.PROPERTY)
-            it.symbol.getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_GETTER, AnnotationUseSiteTarget.PROPERTY)
+
-        }
     }
 
     override fun getSetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir {
+        return symbol.firSymbol.getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_SETTER, AnnotationUseSiteTarget.PROPERTY)
-            it.symbol.getDeprecationForCallSite(AnnotationUseSiteTarget.PROPERTY_SETTER, AnnotationUseSiteTarget.PROPERTY)
-        }
     }
 
     override fun getJavaGetterName(symbol: KtPropertySymbol): Name {
         require(symbol is KtFirSymbol<*>)
         if (symbol is KtFirSyntheticJavaPropertySymbol) {
-            return symbol.firRef.withFir { it.getter.delegate.name }
+            return symbol.javaGetterSymbol.name
         }
-        val jvmName = symbol.firRef.withFir {
+        val jvmName = run {
-            val firProperty = it as? FirProperty ?: return@withFir null
+            val firProperty = symbol.firSymbol.fir as? FirProperty ?: return@run null
             firProperty.getJvmNameFromAnnotation(AnnotationUseSiteTarget.PROPERTY_GETTER) ?: firProperty.getter?.getJvmNameFromAnnotation()
         }
         return Name.identifier(jvmName ?: JvmAbi.getterName(symbol.name.identifier))
@@ -80,13 +77,13 @@ internal class KtFirSymbolInfoProvider(
     override fun getJavaSetterName(symbol: KtPropertySymbol): Name? {
         require(symbol is KtFirSymbol<*>)
         if (symbol is KtFirSyntheticJavaPropertySymbol) {
-            symbol.firRef.withFir { it.setter?.delegate?.name }
+            return symbol.javaSetterSymbol?.name
         }
         return if (symbol.isVal) null
         else {
-            val jvmName = symbol.firRef.withFir {
+            val jvmName = run {
-                val firProperty = it as? FirProperty ?: return@withFir null
+                val firProperty = symbol.firSymbol.fir as? FirProperty ?: return@run null
-                firProperty.getJvmNameFromAnnotation(AnnotationUseSiteTarget.PROPERTY_SETTER)
+                firProperty.getJvmNameFromAnnotation(AnnotationUseSiteTarget.PROPERTY_GETTER)
                     ?: firProperty.setter?.getJvmNameFromAnnotation()
             }
             Name.identifier(jvmName ?: JvmAbi.setterName(symbol.name.identifier))

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeCreator.kt

@@ -10,15 +10,16 @@ import org.jetbrains.kotlin.analysis.api.components.KtTypeCreator
 import org.jetbrains.kotlin.analysis.api.components.KtTypeParameterTypeBuilder
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtClassType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeParameterType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedSymbolError
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.impl.toConeType
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.typeContext
@@ -38,7 +39,7 @@ internal class KtFirTypeCreator(
             is KtClassTypeBuilder.BySymbol -> {
                 val symbol = builder.symbol
                 check(symbol is KtFirSymbol<*>)
-                symbol.firRef.withFir { (it as FirClassLikeDeclaration).symbol.toLookupTag() }
+                (symbol.firSymbol as FirClassLikeSymbol<*>).toLookupTag()
             }
         }
 
@@ -56,8 +57,7 @@ internal class KtFirTypeCreator(
         val coneType = when (builder) {
             is KtTypeParameterTypeBuilder.BySymbol -> {
                 val symbol = builder.symbol
-                check(symbol is KtFirSymbol<*>)
+                (symbol as KtFirTypeParameterSymbol).firSymbol.toConeType()
-                symbol.firRef.withFir { (it as FirTypeParameter).toConeType() }
             }
         }
         return coneType.asKtType() as KtTypeParameterType

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.analysis.api.components.KtTypeProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
+import org.jetbrains.kotlin.analysis.api.fir.symbols.dispatchReceiverType
 import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType
 import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator
 import org.jetbrains.kotlin.analysis.api.fir.utils.toConeNullability
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtPossibleMemberSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
@@ -37,10 +37,8 @@ import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
@@ -72,13 +70,14 @@ internal class KtFirTypeProvider(
 
     override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType {
         require(symbol is KtFirNamedClassOrObjectSymbol)
-        val type = symbol.firRef.withFir(FirResolvePhase.SUPER_TYPES) { firClass ->
+        symbol.firSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
-            ConeClassLikeTypeImpl(
+        val firClass = symbol.firSymbol.fir
-                firClass.symbol.toLookupTag(),
+        val type = ConeClassLikeTypeImpl(
-                firClass.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), isNullable = false) }.toTypedArray(),
+            firClass.symbol.toLookupTag(),
-                isNullable = false
+            firClass.typeParameters.map { ConeTypeParameterTypeImpl(it.symbol.toLookupTag(), isNullable = false) }.toTypedArray(),
-            )
+            isNullable = false
-        }
+        )
+
         return type.asKtType()
     }
 
@@ -190,14 +189,11 @@ internal class KtFirTypeProvider(
 
     override fun getDispatchReceiverType(symbol: KtCallableSymbol): KtType? {
         require(symbol is KtFirSymbol<*>)
-
+        val firSymbol = symbol.firSymbol
-        return symbol.firRef.withFir { declaration ->
+        check(firSymbol is FirCallableSymbol<*>) {
-            check(declaration is FirCallableDeclaration) {
+            "Fir declaration should be FirCallableDeclaration; instead it was ${firSymbol::class}"
-                "Fir declaration should be FirCallableDeclaration; instead it was ${declaration::class}"
-            }
-
-            declaration.dispatchReceiverType?.asKtType()
         }
+        return firSymbol.dispatchReceiverType(analysisSession.firSymbolBuilder)
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt

@@ -6,13 +6,6 @@
 package org.jetbrains.kotlin.analysis.api.fir.components
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.resolve.calls.ExpressionReceiverValue
-import org.jetbrains.kotlin.fir.visibilityChecker
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
 import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol
@@ -21,6 +14,13 @@ import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.resolve.calls.ExpressionReceiverValue
+import org.jetbrains.kotlin.fir.visibilityChecker
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -42,32 +42,26 @@ internal class KtFirVisibilityChecker(
         require(useSiteFile is KtFirFileSymbol)
 
         val nonLocalContainingDeclaration = findContainingNonLocalDeclaration(position)
+        val useSiteFirFile = useSiteFile.firSymbol.fir
+        val containers = nonLocalContainingDeclaration
+            ?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveState)
+            ?.collectDesignation()
+            ?.path
+            .orEmpty()
 
-        return useSiteFile.firRef.withFir { useSiteFirFile ->
+        val explicitDispatchReceiver = receiverExpression
-            val containers = nonLocalContainingDeclaration
+            ?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveState)
-                ?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveState)
+            ?.let { ExpressionReceiverValue(it) }
-                ?.collectDesignation()
-                ?.path
-                .orEmpty()
 
-            val explicitDispatchReceiver = receiverExpression
+        val candidateFirSymbol = candidateSymbol.firSymbol.fir as FirMemberDeclaration
-                ?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveState)
-                ?.let { ExpressionReceiverValue(it) }
 
-            candidateSymbol.firRef.withFir { candidateFirSymbol ->
+        return rootModuleSession.visibilityChecker.isVisible(
-                require(candidateFirSymbol is FirMemberDeclaration) {
+            candidateFirSymbol,
-                    "$candidateFirSymbol must be a FirStatusOwner and FirSymbolOwner; it were ${candidateFirSymbol::class} instead"
+            rootModuleSession,
-                }
+            useSiteFirFile,
-
+            containers,
-                rootModuleSession.visibilityChecker.isVisible(
+            explicitDispatchReceiver
-                    candidateFirSymbol,
+        )
-                    rootModuleSession,
-                    useSiteFirFile,
-                    containers,
-                    explicitDispatchReceiver
-                )
-            }
-        }
     }
 
     private fun findContainingNonLocalDeclaration(element: PsiElement): KtCallableDeclaration? {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt

@@ -12,7 +12,9 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirPackageSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirPackageDirective
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildImport
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
@@ -32,12 +34,8 @@ import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
-import org.jetbrains.kotlin.analysis.api.fir.buildSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -114,7 +112,7 @@ internal object FirReferenceResolveHelper {
                 val boundSymbol = boundSymbol
                 when {
                     !isInLabelReference && boundSymbol is FirCallableSymbol<*> ->
-                        symbolBuilder.callableBuilder.buildExtensionReceiverSymbol(boundSymbol.fir)
+                        symbolBuilder.callableBuilder.buildExtensionReceiverSymbol(boundSymbol)
                     else -> boundSymbol?.fir?.buildSymbol(symbolBuilder)
                 }.let { listOfNotNull(it) }
             }
@@ -345,7 +343,7 @@ internal object FirReferenceResolveHelper {
         symbolBuilder: KtSymbolByFirBuilder,
         fir: FirFile
     ): List<KtSymbol> {
-        return listOf(symbolBuilder.buildSymbol(fir))
+        return listOf(symbolBuilder.buildSymbol(fir.symbol))
     }
 
     @OptIn(ExperimentalStdlibApi::class)
@@ -414,7 +412,7 @@ internal object FirReferenceResolveHelper {
             return listOfNotNull(symbolBuilder.createPackageSymbolIfOneExists(FqName.fromSegments(fqNameSegments)))
         }
         val referencedClass = referencedSymbol.fir
-        val referencedSymbolsByFir = listOfNotNull(symbolBuilder.buildSymbol(referencedClass))
+        val referencedSymbolsByFir = listOfNotNull(symbolBuilder.buildSymbol(referencedSymbol))
         val firSourcePsi = fir.source.psi ?: referencedSymbolsByFir
         if (firSourcePsi !is KtDotQualifiedExpression) return referencedSymbolsByFir
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirReference.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.idea.references
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.api.fir.findReferencePsi
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtSymbolBasedReference
+import org.jetbrains.kotlin.analysis.api.fir.findReferencePsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
@@ -34,7 +34,7 @@ interface KtFirReference : KtReference, KtSymbolBasedReference {
 
     private fun KtSymbol.findPsiForReferenceResolve(): PsiElement? {
         require(this is KtFirSymbol<*>)
-        return firRef.withFir { it.findReferencePsi() }
+        return firSymbol.fir.findReferencePsi()
     }
 
     override val resolver get() = KtFirReferenceResolver

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirDelegatingScope.kt

@@ -5,12 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.scopes
 
-import org.jetbrains.kotlin.fir.isSubstitutionOverride
-import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
-import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
-import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
@@ -19,7 +13,13 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
+import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name
 
 internal open class KtFirDelegatingScope(
@@ -67,14 +67,14 @@ internal fun FirScope.getCallableSymbols(callableNames: Collection<Name>, builde
     callableNames.forEach { name ->
         val callables = mutableListOf<KtCallableSymbol>()
         processFunctionsByName(name) { firSymbol ->
-            callables.add(builder.functionLikeBuilder.buildFunctionSymbol(firSymbol.fir))
+            callables.add(builder.functionLikeBuilder.buildFunctionSymbol(firSymbol))
         }
         processPropertiesByName(name) { firSymbol ->
             val symbol = when {
                 firSymbol is FirPropertySymbol && firSymbol.fir.isSubstitutionOverride -> {
-                    builder.variableLikeBuilder.buildVariableSymbol(firSymbol.fir)
+                    builder.variableLikeBuilder.buildVariableSymbol(firSymbol)
                 }
-                else -> builder.callableBuilder.buildCallableSymbol(firSymbol.fir)
+                else -> builder.callableBuilder.buildCallableSymbol(firSymbol)
             }
             callables.add(symbol)
         }
@@ -97,7 +97,7 @@ internal fun FirScope.getConstructors(builder: KtSymbolByFirBuilder): Sequence<K
     sequence {
         val constructorSymbols = mutableListOf<KtConstructorSymbol>()
         processDeclaredConstructors { firSymbol ->
-            constructorSymbols.add(builder.functionLikeBuilder.buildConstructorSymbol(firSymbol.fir))
+            constructorSymbols.add(builder.functionLikeBuilder.buildConstructorSymbol(firSymbol))
         }
         yieldAll(constructorSymbols)
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirFileScope.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.scopes
 
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
@@ -15,8 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirFileScope(
@@ -33,15 +36,15 @@ internal class KtFirFileScope(
 
     private val _callableNames: Set<Name> by cached {
         val result = mutableSetOf<Name>()
-        owner.firRef.withFir {
+        owner.firSymbol.fir.declarations
-            it.declarations.mapNotNullTo(result) { firDeclaration ->
+            .mapNotNullTo(result) { firDeclaration ->
                 when (firDeclaration) {
                     is FirSimpleFunction -> firDeclaration.name
                     is FirProperty -> firDeclaration.name
                     else -> null
                 }
             }
-        }
+
         result
     }
 
@@ -49,51 +52,48 @@ internal class KtFirFileScope(
 
     private val _classifierNames: Set<Name> by cached {
         val result = mutableSetOf<Name>()
-        owner.firRef.withFir {
+        owner.firSymbol.fir.declarations
-            it.declarations.mapNotNullTo(result) { firDeclaration ->
+            .mapNotNullTo(result) { firDeclaration ->
                 (firDeclaration as? FirRegularClass)?.name
             }
-        }
+
         result
     }
 
     override fun getPossibleClassifierNames(): Set<Name> = _classifierNames
 
     override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
-        owner.firRef.withFir {
+        sequence {
-            sequence {
+            owner.firSymbol.fir.declarations.forEach { firDeclaration ->
-                it.declarations.forEach { firDeclaration ->
+                val callableDeclaration = when (firDeclaration) {
-                    val callableDeclaration = when (firDeclaration) {
+                    is FirSimpleFunction -> firDeclaration.takeIf { nameFilter(firDeclaration.name) }
-                        is FirSimpleFunction -> firDeclaration.takeIf { nameFilter(firDeclaration.name) }
+                    is FirProperty -> firDeclaration.takeIf { nameFilter(firDeclaration.name) }
-                        is FirProperty -> firDeclaration.takeIf { nameFilter(firDeclaration.name) }
+                    else -> null
-                        else -> null
+                }
-                    }
 
-                    if (callableDeclaration != null) {
+                if (callableDeclaration != null) {
-                        yield(builder.callableBuilder.buildCallableSymbol(callableDeclaration))
+                    yield(builder.callableBuilder.buildCallableSymbol(callableDeclaration.symbol))
-                    }
                 }
             }
         }
     }
 
     override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence<KtClassifierSymbol> = withValidityAssertion {
-        owner.firRef.withFir {
+        sequence {
-            sequence {
+            owner.firSymbol.fir.declarations.forEach { firDeclaration ->
-                it.declarations.forEach { firDeclaration ->
+                val classLikeDeclaration = when (firDeclaration) {
-                    val classLikeDeclaration = when (firDeclaration) {
                         is FirTypeAlias -> if (nameFilter(firDeclaration.name)) firDeclaration else null
                         is FirRegularClass -> if (nameFilter(firDeclaration.name)) firDeclaration else null
                         else -> null
                     }
-                    if (classLikeDeclaration != null) {
+                if (classLikeDeclaration != null) {
-                        yield(builder.classifierBuilder.buildClassLikeSymbol(classLikeDeclaration))
+                    yield(builder.classifierBuilder.buildClassLikeSymbol(classLikeDeclaration.symbol))
-                    }
                 }
             }
         }
     }
 
+
     override fun getConstructors(): Sequence<KtConstructorSymbol> = emptySequence()
 
     override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirNonStarImportingScope.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractSimpleImportingScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirDefaultSimpleImportingScope
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt

@@ -6,46 +6,41 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 
 internal class KtFirAnonymousFunctionSymbol(
-    fir: FirAnonymousFunction,
+    override val firSymbol: FirAnonymousFunctionSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
-    private val builder: KtSymbolByFirBuilder
+    private val builder: KtSymbolByFirBuilder,
-) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunction> {
+) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {
-    override val firRef = firRef(fir, resolveState)
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val returnType: KtType by cached {
+    override val psi: PsiElement? by cached { firSymbol.fir.findPsi(firSymbol.fir.moduleData.session) }
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
 
-    override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        fir.valueParameters.map { valueParameter ->
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
-            builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter)
+
+    override val valueParameters: List<KtValueParameterSymbol> by cached { firSymbol.createKtValueParameters(builder) }
+
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion {
+            firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session)
         }
-    }
+    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
 
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
-
-    override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
-    override val receiverType: KtType? by cached {
-        firRef.receiverType(builder)
-    }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousObjectSymbol.kt

@@ -6,33 +6,30 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 
 internal class KtFirAnonymousObjectSymbol(
-    fir: FirAnonymousObject,
+    override val firSymbol: FirAnonymousObjectSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
-    private val builder: KtSymbolByFirBuilder
+    private val builder: KtSymbolByFirBuilder,
-) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObject> {
+) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
-
+    override val superTypes: List<KtType> by cached { firSymbol.superTypesList(builder) }
-    override val superTypes: List<KtType> by cached { firRef.superTypesList(builder) }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> =
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirArrayOfSymbolProvider.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -16,13 +16,13 @@ import org.jetbrains.kotlin.name.StandardClassIds
 
 object KtFirArrayOfSymbolProvider {
     internal fun KtFirAnalysisSession.arrayOfSymbol(identifier: Name): KtFirFunctionSymbol? {
-        val fir = firResolveState.rootModuleSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
+        val firSymbol = firResolveState.rootModuleSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
             /* choose (for byte array)
              * public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray
              */
             (it as? FirFunctionSymbol<*>)?.fir?.valueParameters?.singleOrNull()?.isVararg == true
-        }?.fir as? FirSimpleFunction ?: return null
+        } as? FirNamedFunctionSymbol ?: return null
-        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(fir)
+        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firSymbol)
     }
 
     private val kotlinPackage = FqName("kotlin")

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirBackingFieldSymbol.kt

@@ -7,8 +7,6 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirBackingFieldSymbolPointer
-import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
@@ -17,27 +15,22 @@ import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.fir.declarations.FirBackingField
+import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 
 internal class KtFirBackingFieldSymbol(
-    fir: FirBackingField,
+    override val firSymbol: FirBackingFieldSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingField> {
+) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val origin: KtSymbolOrigin get() = withValidityAssertion { super<KtBackingFieldSymbol>.origin }
 
-    override val origin: KtSymbolOrigin
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        get() = withValidityAssertion { super<KtBackingFieldSymbol>.origin }
 
-    override val returnType: KtType by cached {
+    override val owningProperty: KtKotlinPropertySymbol
-        firRef.returnType(FirResolvePhase.TYPES, builder)
+        get() = withValidityAssertion {
-    }
+            builder.variableLikeBuilder.buildPropertySymbol(firSymbol.propertySymbol) as KtKotlinPropertySymbol
-
+        }
-    override val owningProperty: KtKotlinPropertySymbol by firRef.withFirAndCache { fir ->
-        builder.buildSymbol(fir.propertySymbol.fir) as KtKotlinPropertySymbol
-    }
 
     override fun createPointer(): KtSymbolPointer<KtBackingFieldSymbol> {
         return KtFirBackingFieldSymbolPointer(owningProperty.createPointer())
@@ -49,10 +42,10 @@ internal class KtFirBackingFieldSymbol(
 
         other as KtFirBackingFieldSymbol
 
-        return this.firRef == other.firRef
+        return this.firSymbol == other.firSymbol
     }
 
     override fun hashCode(): Int {
-        return firRef.hashCode() * 31 + token.hashCode()
+        return firSymbol.hashCode() * 31 + token.hashCode()
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirClassInitializerSymbol.kt

@@ -7,22 +7,21 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
+import org.jetbrains.kotlin.analysis.api.fir.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassInitializerSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
+import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
 
 internal class KtFirClassInitializerSymbol(
-    fir: FirAnonymousInitializer,
+    override val firSymbol: FirAnonymousInitializerSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
-) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializer> {
+) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializerSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
     override fun createPointer(): KtSymbolPointer<KtSymbol> {
         TODO("Figure out how to create such a pointer. Should we give an index to class initializers?")

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirConstructorSymbol.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirConstructorSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.createSignature
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
@@ -25,47 +24,39 @@ import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirConstructorSymbol(
-    fir: FirConstructor,
+    override val firSymbol: FirConstructorSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtConstructorSymbol(), KtFirSymbol<FirConstructor> {
+) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+    
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
 
-    override val returnType: KtType by cached {
+    override val valueParameters: List<KtValueParameterSymbol> by cached { firSymbol.createKtValueParameters(builder) }
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
 
-    override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
+    override val hasStableParameterNames: Boolean
-        fir.valueParameters.map { valueParameter ->
+        get() = withValidityAssertion {
-            builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter)
+            firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session)
         }
-    }
 
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
-
-    override val visibility: Visibility get() = getVisibility()
-
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
 
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
     override val containingClassIdIfNonLocal: ClassId?
-        get() = firRef.withFir { fir -> fir.containingClass()?.classId /* TODO check if local */ }
+        get() = withValidityAssertion { firSymbol.containingClass()?.classId?.takeUnless { it.isLocal } }
 
-    override val isPrimary: Boolean get() = firRef.withFir { it.isPrimary }
+    override val isPrimary: Boolean get() = withValidityAssertion { firSymbol.isPrimary }
+
+    override val typeParameters by cached { firSymbol.createKtTypeParameters(builder) }
 
-    override val typeParameters by firRef.withFirAndCache { fir ->
-        fir.typeParameters.map { typeParameter ->
-            builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol.fir)
-        }
-    }
 
     override fun createPointer(): KtSymbolPointer<KtConstructorSymbol> = withValidityAssertion {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
@@ -74,7 +65,7 @@ internal class KtFirConstructorSymbol(
         }
         val ownerClassId = containingClassIdIfNonLocal
             ?: error("ClassId should present for member declaration")
-        return KtFirConstructorSymbolPointer(ownerClassId, isPrimary, firRef.withFir { it.createSignature() })
+        return KtFirConstructorSymbolPointer(ownerClassId, isPrimary, firSymbol.fir.createSignature())
     }
 
     override fun equals(other: Any?): Boolean = symbolEquals(other)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirEnumEntrySymbol.kt

@@ -6,52 +6,43 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirEnumEntrySymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirEnumEntrySymbol(
-    fir: FirEnumEntry,
+    override val firSymbol: FirEnumEntrySymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntry> {
+) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
 
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
+    override val containingEnumClassIdIfNonLocal: ClassId? get() = callableIdIfNonLocal?.classId
 
-    override val name: Name get() = firRef.withFir { it.name }
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
-    override val returnType: KtType by cached {
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
-
-    override val containingEnumClassIdIfNonLocal: ClassId?
-        get() = firRef.withFir { it.containingClass()?.classId?.takeUnless { it.isLocal } }
-
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
 
     override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
-        return firRef.withFir { fir ->
+        return KtFirEnumEntrySymbolPointer(
-            KtFirEnumEntrySymbolPointer(
+            firSymbol.containingClass()?.classId ?: error("Containing class should present for enum entry"),
-                fir.symbol.containingClass()?.classId ?: error("Containing class should present for enum entry"),
+            firSymbol.name
-                fir.name
+        )
-            )
-        }
     }
 
     override fun equals(other: Any?): Boolean = symbolEquals(other)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFileSymbol.kt

@@ -7,31 +7,29 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithDeclarations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
 
 internal class KtFirFileSymbol(
-    fir: FirFile,
+    override val firSymbol: FirFileSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
-) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFile> {
+) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFileSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
     override fun createPointer(): KtSymbolPointer<KtFileSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
         TODO("Creating pointers for files from library is not supported yet")
     }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
     override fun equals(other: Any?): Boolean = symbolEquals(other)
     override fun hashCode(): Int = symbolHashCode()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFunctionSymbol.kt

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirMemberFunctio
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirTopLevelFunctionSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.createSignature
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.impl.base.util.kotlinFunctionInvokeCallableIds
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
@@ -24,94 +23,82 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConstructor
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirFunctionSymbol(
-    fir: FirSimpleFunction,
+    override val firSymbol: FirNamedFunctionSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtFunctionSymbol(), KtFirSymbol<FirSimpleFunction> {
+) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    override val name: Name get() = firRef.withFir { it.name }
-    override val returnType: KtType by cached {
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
-
-    override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
-        fir.valueParameters.map { valueParameter ->
-            builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter)
-        }
-    }
-
-    override val typeParameters by firRef.withFirAndCache { fir ->
-        fir.typeParameters.map { typeParameter ->
-            builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol.fir)
-        }
-    }
-
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
-
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-
-
-    override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend }
-    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
-    override val isInfix: Boolean get() = firRef.withFir { it.isInfix }
-    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }
 
     override val isBuiltinFunctionInvoke: Boolean
-        get() = callableIdIfNonLocal in kotlinFunctionInvokeCallableIds
+        get() = withValidityAssertion { callableIdIfNonLocal in kotlinFunctionInvokeCallableIds }
 
-    override val receiverType: KtType? by cached {
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        firRef.receiverType(builder)
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
-    }
+    
+    override val typeParameters by cached { firSymbol.createKtTypeParameters(builder) }
+    override val valueParameters: List<KtValueParameterSymbol> by cached { firSymbol.createKtValueParameters(builder) }
 
-    override val isOperator: Boolean get() = firRef.withFir { it.isOperator }
+    override val hasStableParameterNames: Boolean
-    override val isExternal: Boolean get() = firRef.withFir { it.isExternal }
+        get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) }
-    override val isInline: Boolean get() = firRef.withFir { it.isInline }
+
-    override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
+
+    override val isSuspend: Boolean get() = withValidityAssertion { firSymbol.isSuspend }
+    override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
+    override val isInfix: Boolean get() = withValidityAssertion { firSymbol.isInfix }
+    override val isStatic: Boolean get() = withValidityAssertion { firSymbol.isStatic }
+
+
+    override val isOperator: Boolean get() = withValidityAssertion { firSymbol.isOperator }
+    override val isExternal: Boolean get() = withValidityAssertion { firSymbol.isExternal }
+    override val isInline: Boolean get() = withValidityAssertion { firSymbol.isInline }
+    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 
     override val symbolKind: KtSymbolKind
-        get() = firRef.withFir { fir ->
+        get() = withValidityAssertion {
             when {
-                fir.isLocal -> KtSymbolKind.LOCAL
+                firSymbol.isLocal -> KtSymbolKind.LOCAL
-                fir.containingClass()?.classId == null -> KtSymbolKind.TOP_LEVEL
+                firSymbol.containingClass()?.classId == null -> KtSymbolKind.TOP_LEVEL
                 else -> KtSymbolKind.CLASS_MEMBER
             }
         }
-    override val modality: Modality get() = getModality()
 
-    override val visibility: Visibility get() = getVisibility()
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
     override fun createPointer(): KtSymbolPointer<KtFunctionSymbol> {
-        if (firRef.withFir { it.origin != FirDeclarationOrigin.SubstitutionOverride }) {
+        if (firSymbol.fir.origin != FirDeclarationOrigin.SubstitutionOverride) {
             KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
         }
 
         return when (symbolKind) {
-            KtSymbolKind.TOP_LEVEL -> firRef.withFir { fir ->
+            KtSymbolKind.TOP_LEVEL ->
-                KtFirTopLevelFunctionSymbolPointer(fir.symbol.callableId, fir.createSignature())
+                KtFirTopLevelFunctionSymbolPointer(firSymbol.callableId, firSymbol.createSignature())
-            }
+
-            KtSymbolKind.CLASS_MEMBER -> firRef.withFir { fir ->
+            KtSymbolKind.CLASS_MEMBER ->
                 KtFirMemberFunctionSymbolPointer(
-                    fir.containingClass()?.classId ?: error("ClassId should not be null for member function"),
+                    firSymbol.containingClass()?.classId ?: error("ClassId should not be null for member function"),
-                    fir.name,
+                    firSymbol.name,
-                    fir.createSignature()
+                    firSymbol.createSignature()
                 )
-            }
+
             KtSymbolKind.ACCESSOR -> TODO("Creating symbol for accessors fun is not supported yet")
             KtSymbolKind.LOCAL -> throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(
                 callableIdIfNonLocal?.toString() ?: name.asString()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirJavaFieldSymbol.kt

@@ -6,49 +6,47 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.FirField
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.utils.isStatic
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirJavaFieldSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtJavaFieldSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
+import org.jetbrains.kotlin.fir.declarations.utils.isStatic
+import org.jetbrains.kotlin.fir.declarations.utils.modalityOrFinal
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
+import org.jetbrains.kotlin.fir.symbols.impl.FirFieldSymbol
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirJavaFieldSymbol(
-    fir: FirField,
+    override val firSymbol: FirFieldSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtJavaFieldSymbol(), KtFirSymbol<FirField> {
+) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val returnType: KtType by cached {
+    override val isVal: Boolean get() = withValidityAssertion { firSymbol.fir.isVal }
-        firRef.returnType(FirResolvePhase.TYPES, builder)
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    }
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-    override val isVal: Boolean get() = firRef.withFir { it.isVal }
-    override val name: Name get() = firRef.withFir { it.name }
 
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 
-    override val modality: Modality get() = getModality()
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val visibility: Visibility get() = getVisibility()
+    override val isStatic: Boolean get() = withValidityAssertion { firSymbol.isStatic }
-    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }
 
     override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> {
-        val containingClassId = firRef.withFir { it.containingClass()?.classId }
+        val containingClassId = firSymbol.containingClass()?.classId
             ?: error("Cannot find parent class for java field $callableIdIfNonLocal")
 
         return KtFirJavaFieldSymbolPointer(containingClassId, name)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt

@@ -7,14 +7,13 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.createSignature
-import org.jetbrains.kotlin.analysis.api.fir.utils.asKtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
@@ -26,107 +25,111 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConstructor
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.*
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirKotlinPropertySymbol(
-    fir: FirProperty,
+    override val firSymbol: FirPropertySymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtKotlinPropertySymbol(), KtFirSymbol<FirProperty> {
+) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> {
     init {
-        assert(!fir.isLocal)
+        assert(!firSymbol.isLocal)
-        check(fir !is FirSyntheticProperty)
+        check(firSymbol !is FirSyntheticPropertySymbol)
+        check(firSymbol.fir !is FirSyntheticProperty)
     }
 
-    override val firRef = firRef(fir, resolveState)
+    override val isDelegatedProperty: Boolean
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+        get() = withValidityAssertion { firSymbol.delegateFieldSymbol != null }
 
-    override val isVal: Boolean get() = firRef.withFir { it.isVal }
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val name: Name get() = firRef.withFir { it.name }
 
-    override val returnType: KtType by cached {
+    override val isVal: Boolean get() = withValidityAssertion { firSymbol.isVal }
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    }
 
-    override val typeParameters: List<KtTypeParameterSymbol> by cached {
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        fir.typeParameters.map { builder.classifierBuilder.buildTypeParameterSymbol(it) }
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
-    }
+    
 
-    override val receiverType: KtType? by cached {
+    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
-        firRef.receiverType(builder)
+    override val initializer: KtInitializerValue? by cached { firSymbol.getKtConstantInitializer() }
-    }
 
-    override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
-    override val initializer by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir ->
-        fir.initializer?.asKtInitializerValue()
-    }
     override val symbolKind: KtSymbolKind
-        get() = firRef.withFir { fir ->
+        get() = withValidityAssertion {
-            when (fir.containingClass()?.classId) {
+            when (firSymbol.containingClass()?.classId) {
                 null -> KtSymbolKind.TOP_LEVEL
                 else -> KtSymbolKind.CLASS_MEMBER
             }
         }
-    override val modality: Modality get() = getModality()
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
 
-    override val visibility: Visibility get() = getVisibility()
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
+    override val typeParameters: List<KtTypeParameterSymbol>
+        get() = withValidityAssertion { firSymbol.createKtTypeParameters(builder) }
 
-    override val getter: KtPropertyGetterSymbol? by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { property ->
+    override val getter: KtPropertyGetterSymbol?
-        property.getter?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertyGetterSymbol
+        get() = withValidityAssertion {
-    }
+            firSymbol.getterSymbol?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertyGetterSymbol
+        }
 
-    override val setter: KtPropertySetterSymbol? by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { property ->
+    override val setter: KtPropertySetterSymbol?
-        property.setter?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertySetterSymbol
+        get() = withValidityAssertion {
-    }
+            firSymbol.setterSymbol?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertySetterSymbol
+        }
 
     // NB: `field` in accessors indicates the property should have a backing field. To see that, though, we need BODY_RESOLVE.
-    override val hasBackingField: Boolean get() = firRef.withFir(FirResolvePhase.BODY_RESOLVE) { it.hasBackingField }
+    override val hasBackingField: Boolean
+        get() = withValidityAssertion {
+            firSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            firSymbol.fir.hasBackingField
+        }
+    override val isLateInit: Boolean get() = withValidityAssertion { firSymbol.isLateInit }
 
-    override val isDelegatedProperty: Boolean get() = firRef.withFir { it.delegateFieldSymbol != null }
-
-    override val isLateInit: Boolean get() = firRef.withFir { it.isLateInit }
-
-    override val isConst: Boolean get() = firRef.withFir { it.isConst }
 
     override val isFromPrimaryConstructor: Boolean
-        get() = firRef.withFir {
+        get() = withValidityAssertion {
-            it.fromPrimaryConstructor == true || it.source?.kind == KtFakeSourceElementKind.PropertyFromParameter
+            firSymbol.fir.fromPrimaryConstructor == true || firSymbol.source?.kind == KtFakeSourceElementKind.PropertyFromParameter
         }
-    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
-    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }
 
-    override val hasGetter: Boolean get() = firRef.withFir { it.getter != null }
+    override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
-    override val hasSetter: Boolean get() = firRef.withFir { it.setter != null }
+    override val isConst: Boolean get() = withValidityAssertion { firSymbol.isConst }
+    override val isStatic: Boolean get() = withValidityAssertion { firSymbol.isStatic }
+
+    override val hasGetter: Boolean get() = withValidityAssertion { firSymbol.getterSymbol != null }
+    override val hasSetter: Boolean get() = withValidityAssertion { firSymbol.setterSymbol != null }
 
     override fun createPointer(): KtSymbolPointer<KtKotlinPropertySymbol> {
-        if (firRef.withFir { it.origin != FirDeclarationOrigin.SubstitutionOverride }) {
+        if (firSymbol.fir.origin != FirDeclarationOrigin.SubstitutionOverride) {
             KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
         }
 
         return when (symbolKind) {
             KtSymbolKind.TOP_LEVEL -> TODO("Creating symbol for top level properties is not supported yet")
-            KtSymbolKind.CLASS_MEMBER -> firRef.withFir { fir ->
+            KtSymbolKind.CLASS_MEMBER ->
                 KtFirMemberPropertySymbolPointer(
-                    fir.containingClass()?.classId ?: error("ClassId should not be null for member property"),
+                    firSymbol.containingClass()?.classId ?: error("ClassId should not be null for member property"),
-                    fir.name,
+                    firSymbol.name,
-                    fir.createSignature()
+                    firSymbol.createSignature()
                 )
-            }
+
             KtSymbolKind.ACCESSOR -> TODO("Creating symbol for accessors is not supported yet")
             KtSymbolKind.LOCAL -> throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(name.asString())
             KtSymbolKind.SAM_CONSTRUCTOR -> throw WrongSymbolForSamConstructor(this::class.java.simpleName)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirLocalVariableSymbol.kt

@@ -6,13 +6,9 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
@@ -20,27 +16,28 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirLocalVariableSymbol(
-    fir: FirProperty,
+    override val firSymbol: FirPropertySymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
 ) : KtLocalVariableSymbol(),
-    KtFirSymbol<FirProperty> {
+    KtFirSymbol<FirPropertySymbol> {
     init {
-        assert(fir.isLocal)
+        assert(firSymbol.isLocal)
     }
 
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+
+    override val isVal: Boolean get() = withValidityAssertion { firSymbol.isVal }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
 
-    override val isVal: Boolean get() = firRef.withFir { it.isVal }
-    override val name: Name get() = firRef.withFir { it.name }
-    override val returnType: KtType by cached {
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
     override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL
 
     override fun createPointer(): KtSymbolPointer<KtLocalVariableSymbol> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirNamedClassOrObjectSymbol.kt

@@ -6,19 +6,11 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.utils.*
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirClassOrObjectInLibrarySymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
@@ -27,85 +19,99 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
+import org.jetbrains.kotlin.fir.declarations.utils.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirNamedClassOrObjectSymbol(
-    fir: FirRegularClass,
+    override val firSymbol: FirRegularClassSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClass> {
+) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+
-    override val name: Name get() = firRef.withFir { it.name }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
+
     override val classIdIfNonLocal: ClassId?
-        get() = firRef.withFir { fir ->
+        get() = withValidityAssertion { firSymbol.classId.takeUnless { it.isLocal } }
-            fir.symbol.classId.takeUnless { it.isLocal }
+
+    /* FirRegularClass modality is not modified by STATUS, so it can be taken from RAW */
+    override val modality: Modality
+        get() = withValidityAssertion {
+            firSymbol.fir.modality
+                ?: when (classKind) { // default modality
+                    KtClassKind.INTERFACE -> Modality.ABSTRACT
+                    // Enum class should not be `final`, since its entries extend it.
+                    // It could be either `abstract` w/o ctor, or empty modality w/ private ctor.
+                    KtClassKind.ENUM_CLASS -> Modality.OPEN
+                    else -> Modality.FINAL
+                }
         }
 
-    /* FirRegularClass modality does not modified by STATUS so it can be taken from RAW */
-    override val modality: Modality
-        get() = getModality(
-            FirResolvePhase.RAW_FIR,
-            when (classKind) { // default modality
-                KtClassKind.INTERFACE -> Modality.ABSTRACT
-                // Enum class should not be `final`, since its entries extend it.
-                // It could be either `abstract` w/o ctor, or empty modality w/ private ctor.
-                KtClassKind.ENUM_CLASS -> Modality.OPEN
-                else -> Modality.FINAL
-            }
-        )
 
-    /* FirRegularClass visibility are not modified by STATUS only for Unknown so it can be taken from RAW */
+    /* FirRegularClass visibility is not modified by STATUS only for Unknown, so it can be taken from RAW */
     override val visibility: Visibility
-        get() = when (val possiblyRawVisibility = getVisibility(FirResolvePhase.RAW_FIR)) {
+        get() = when (val possiblyRawVisibility = firSymbol.fir.visibility) {
-            Visibilities.Unknown -> if (firRef.withFir { it.isLocal }) Visibilities.Local else Visibilities.Public
+            Visibilities.Unknown -> if (firSymbol.fir.isLocal) Visibilities.Local else Visibilities.Public
             else -> possiblyRawVisibility
         }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
-    override val isInner: Boolean get() = firRef.withFir { it.isInner }
+    override val isInner: Boolean get() = withValidityAssertion { firSymbol.isInner }
-    override val isData: Boolean get() = firRef.withFir { it.isData }
+    override val isData: Boolean get() = withValidityAssertion { firSymbol.isData }
-    override val isInline: Boolean get() = firRef.withFir { it.isInline }
+    override val isInline: Boolean get() = withValidityAssertion { firSymbol.isInline }
-    override val isFun: Boolean get() = firRef.withFir { it.isFun }
+    override val isFun: Boolean get() = withValidityAssertion { firSymbol.isFun }
-    override val isExternal: Boolean get() = firRef.withFir { it.isExternal }
+    override val isExternal: Boolean get() = withValidityAssertion { firSymbol.isExternal }
 
-    override val companionObject: KtFirNamedClassOrObjectSymbol? by firRef.withFirAndCache { fir ->
+    override val companionObject: KtFirNamedClassOrObjectSymbol? by cached {
-        fir.companionObjectSymbol?.let { builder.classifierBuilder.buildNamedClassOrObjectSymbol(it.fir) }
+        firSymbol.companionObjectSymbol?.let {
-    }
+            builder.classifierBuilder.buildNamedClassOrObjectSymbol(it)
-
-    override val superTypes: List<KtType> by cached {
-        firRef.superTypesAndAnnotationsListForRegularClass(builder)
-    }
-
-    override val typeParameters by firRef.withFirAndCache { fir ->
-        fir.typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
-            builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol.fir)
         }
     }
 
+    override val superTypes: List<KtType> by cached {
+        firSymbol.superTypesAndAnnotationsListForRegularClass(builder)
+    }
+
+    override val typeParameters = withValidityAssertion {
+        firSymbol.fir.typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
+            builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol)
+        }
+    }
+
+
     override val classKind: KtClassKind
-        get() = firRef.withFir { fir ->
+        get() = withValidityAssertion {
-            when (fir.classKind) {
+            when (firSymbol.classKind) {
                 ClassKind.INTERFACE -> KtClassKind.INTERFACE
                 ClassKind.ENUM_CLASS -> KtClassKind.ENUM_CLASS
                 ClassKind.ENUM_ENTRY -> KtClassKind.ENUM_ENTRY
                 ClassKind.ANNOTATION_CLASS -> KtClassKind.ANNOTATION_CLASS
                 ClassKind.CLASS -> KtClassKind.CLASS
-                ClassKind.OBJECT -> if (fir.isCompanion) KtClassKind.COMPANION_OBJECT else KtClassKind.OBJECT
+                ClassKind.OBJECT -> if (firSymbol.isCompanion) KtClassKind.COMPANION_OBJECT else KtClassKind.OBJECT
             }
         }
+
     override val symbolKind: KtSymbolKind
-        get() = firRef.withFir { fir ->
+        get() = withValidityAssertion {
             when {
-                fir.isLocal -> KtSymbolKind.LOCAL
+                firSymbol.isLocal -> KtSymbolKind.LOCAL
-                fir.symbol.classId.isNestedClass -> KtSymbolKind.CLASS_MEMBER
+                firSymbol.classId.isNestedClass -> KtSymbolKind.CLASS_MEMBER
                 else -> KtSymbolKind.TOP_LEVEL
             }
         }
 
+
     override fun createPointer(): KtSymbolPointer<KtNamedClassOrObjectSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
         if (symbolKind == KtSymbolKind.LOCAL) {

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

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.util.ImplementationStatus
 
 internal class KtFirOverrideInfoProvider(
@@ -36,15 +37,11 @@ internal class KtFirOverrideInfoProvider(
         require(classSymbol is KtFirSymbol<*>)
 
         // Inspecting visibility requires resolving to status
-        return memberSymbol.firRef.withFir(FirResolvePhase.STATUS) outer@{ memberFir ->
+        classSymbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
-            if (memberFir !is FirCallableDeclaration) return@outer false
+        val memberFir = memberSymbol.firSymbol.fir as? FirCallableDeclaration ?: return false
+        val parentClassFir = classSymbol.firSymbol.fir as? FirClass ?: return false
 
-            classSymbol.firRef.withFir inner@{ parentClassFir ->
+        return memberFir.isVisibleInClass(parentClassFir)
-                if (parentClassFir !is FirClass) return@inner false
-
-                memberFir.isVisibleInClass(parentClassFir)
-            }
-        }
     }
 
     override fun getImplementationStatus(memberSymbol: KtCallableSymbol, parentClassSymbol: KtClassOrObjectSymbol): ImplementationStatus? {
@@ -52,39 +49,32 @@ internal class KtFirOverrideInfoProvider(
         require(parentClassSymbol is KtFirSymbol<*>)
 
         // Inspecting implementation status requires resolving to status
-        return memberSymbol.firRef.withFir(FirResolvePhase.STATUS) outer@{ memberFir ->
+        parentClassSymbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
-            if (memberFir !is FirCallableDeclaration) return@outer null
+        val memberFir = memberSymbol.firSymbol.fir as? FirCallableDeclaration ?: return null
+        val parentClassFir = parentClassSymbol.firSymbol.fir as? FirClass ?: return null
 
-            parentClassSymbol.firRef.withFir inner@{ parentClassFir ->
+        return memberFir.symbol.getImplementationStatus(
-                if (parentClassFir !is FirClass) return@inner null
+            SessionHolderImpl(rootModuleSession, ScopeSession()),
-
+            parentClassFir.symbol
-                memberFir.symbol.getImplementationStatus(
+        )
-                    SessionHolderImpl(rootModuleSession, ScopeSession()),
-                    parentClassFir.symbol
-                )
-            }
-        }
     }
 
     override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir(FirResolvePhase.STATUS) { firDeclaration ->
+        symbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
-            if (firDeclaration !is FirCallableDeclaration) return@withFir null
+        val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration
-            val containingClass =
+        val containingClass =
-                getOriginalOverriddenSymbol(firDeclaration)?.containingClass()?.toSymbol(rootModuleSession) ?: return@withFir null
+            getOriginalOverriddenSymbol(firDeclaration)?.containingClass()?.toSymbol(rootModuleSession) ?: return null
-            analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(containingClass.fir) as? KtClassOrObjectSymbol
+        return analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(containingClass.fir.symbol) as? KtClassOrObjectSymbol
-        }
+
     }
 
     override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? {
         require(symbol is KtFirSymbol<*>)
-        return symbol.firRef.withFir(FirResolvePhase.STATUS) { firDeclaration ->
+        symbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
-            if (firDeclaration !is FirCallableDeclaration) return@withFir null
+        val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration
-            with(analysisSession) {
+        return getOriginalOverriddenSymbol(firDeclaration)
-                getOriginalOverriddenSymbol(firDeclaration)
+            ?.buildSymbol(analysisSession.firSymbolBuilder) as KtCallableSymbol?
-                    ?.buildSymbol((analysisSession as KtFirAnalysisSession).firSymbolBuilder) as KtCallableSymbol?
-            }
-        }
     }
 
     private fun getOriginalOverriddenSymbol(member: FirCallableDeclaration): FirCallableDeclaration? {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPackageSymbol.kt

@@ -11,14 +11,15 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.file.PsiPackageImpl
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointer
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.name.FqName
 
 class KtFirPackageSymbol(

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertyGetterSymbol.kt

@@ -10,69 +10,67 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
+import org.jetbrains.kotlin.fir.declarations.utils.modalityOrFinal
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.name.CallableId
 
 internal class KtFirPropertyGetterSymbol(
-    fir: FirPropertyAccessor,
+    override val firSymbol: FirPropertyAccessorSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
-) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessor> {
+) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
     init {
-        require(fir.isGetter)
+        require(firSymbol.isGetter)
     }
 
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val isDefault: Boolean get() = firRef.withFir { it is FirDefaultPropertyAccessor }
+    override val isDefault: Boolean get() = withValidityAssertion { firSymbol.fir is FirDefaultPropertyAccessor }
-    override val isInline: Boolean get() = firRef.withFir { it.isInline }
+    override val isInline: Boolean get() = withValidityAssertion { firSymbol.isInline }
-    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
+    override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
-    override val hasBody: Boolean get() = firRef.withFir { it.body != null }
+    override val hasBody: Boolean get() = withValidityAssertion { firSymbol.fir.body != null }
 
-    override val returnType: KtType by cached {
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
-    }
-    override val modality: Modality get() = getModality()
-    override val visibility: Visibility get() = getVisibility()
-        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
 
 
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
+    
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
+
     /**
-     * Returns [CallableId] of the delegated Java method if the corresponding property of this getter is a synthetic Java property.
+     * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
      * Otherwise, returns `null`
      */
-    override val callableIdIfNonLocal: CallableId? by firRef.withFirAndCache { fir ->
+    override val callableIdIfNonLocal: CallableId? by cached {
+        val fir = firSymbol.fir
         if (fir is FirSyntheticPropertyAccessor) {
             fir.delegate.symbol.callableId
         } else null
     }
 
-    override val receiverType: KtType? by cached {
+    override val valueParameters: List<KtValueParameterSymbol> get() = withValidityAssertion { emptyList() }
-        firRef.receiverType(builder)
-    }
 
-    override val valueParameters: List<KtValueParameterSymbol>
+    override val hasStableParameterNames: Boolean
-        get() = emptyList()
+        get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) }
-
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertySetterSymbol.kt

@@ -10,74 +10,72 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
+import org.jetbrains.kotlin.fir.declarations.utils.modalityOrFinal
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.name.CallableId
 
 internal class KtFirPropertySetterSymbol(
-    fir: FirPropertyAccessor,
+    override val firSymbol: FirPropertyAccessorSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
-) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessor> {
+) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
+
     init {
-        require(fir.isSetter)
+        require(firSymbol.isSetter)
     }
 
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val isDefault: Boolean get() = firRef.withFir { it is FirDefaultPropertyAccessor }
+    override val isDefault: Boolean get() = withValidityAssertion { firSymbol.fir is FirDefaultPropertyAccessor }
-    override val isInline: Boolean get() = firRef.withFir { it.isInline }
+    override val isInline: Boolean get() = withValidityAssertion { firSymbol.isInline }
-    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
+    override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
-    override val hasBody: Boolean get() = firRef.withFir { it.body != null }
+    override val hasBody: Boolean get() = withValidityAssertion { firSymbol.fir.body != null }
 
-    override val modality: Modality get() = getModality()
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
-    override val visibility: Visibility get() = getVisibility()
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
-
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
 
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
     /**
      * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
      * Otherwise, returns `null`
      */
-    override val callableIdIfNonLocal: CallableId? by firRef.withFirAndCache { fir ->
+    override val callableIdIfNonLocal: CallableId? by cached {
+        val fir = firSymbol.fir
         if (fir is FirSyntheticPropertyAccessor) {
             fir.delegate.symbol.callableId
         } else null
     }
 
-    override val parameter: KtValueParameterSymbol by firRef.withFirAndCache { fir ->
+    override val parameter: KtValueParameterSymbol by cached {
-        builder.variableLikeBuilder.buildValueParameterSymbol(fir.valueParameters.single())
+        builder.variableLikeBuilder.buildValueParameterSymbol(firSymbol.fir.valueParameters.single().symbol)
     }
 
     override val valueParameters: List<KtValueParameterSymbol> by cached { listOf(parameter) }
 
-    override val returnType: KtType by cached {
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
-    }
+    
 
-    override val receiverType: KtType? by cached {
+    override val hasStableParameterNames: Boolean
-        firRef.receiverType(builder)
+        get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) }
-    }
-
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirReceiverParameterSymbol.kt

@@ -10,35 +10,37 @@ import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtReceiverParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.originalOrSelf
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 
 internal class KtFirReceiverParameterSymbol(
-    fir: FirCallableDeclaration,
+    val firSymbol: FirCallableSymbol<*>,
-    resolveState: FirModuleResolveState,
+    val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     _builder: KtSymbolByFirBuilder
 ) : KtReceiverParameterSymbol(), ValidityTokenOwner {
+    override val psi: PsiElement? by cached { firSymbol.fir.receiverTypeRef?.findPsi(firSymbol.fir.moduleData.session) }
+
     init {
-        require(fir.receiverTypeRef != null) { "$fir doesn't have an extension receiver." }
+        require(firSymbol.fir.receiverTypeRef != null) { "$firSymbol doesn't have an extension receiver." }
     }
 
     private val builder by weakRef(_builder)
-    internal val firRef = firRef(fir, resolveState)
 
     override val type: KtType by cached {
-        firRef.receiverType(builder) ?: throw IllegalStateException("$fir doesn't have an extension receiver.")
+        firSymbol.receiverType(builder)
+            ?: error("$firSymbol doesn't have an extension receiver.")
     }
-    override val origin: KtSymbolOrigin get() = firRef.withFir { it.ktSymbolOrigin() }
 
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.receiverTypeRef?.findPsi(fir.moduleData.session) }
+    override val origin: KtSymbolOrigin = withValidityAssertion { firSymbol.fir.ktSymbolOrigin() }
 
     override fun createPointer(): KtSymbolPointer<KtFirReceiverParameterSymbol> {
         TODO("Probably just create a pointer based on the underlying declaration")

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSamConstructorSymbol.kt

@@ -6,56 +6,55 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirSamConstructorSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSamConstructorSymbol(
-    fir: FirSimpleFunction,
+    override val firSymbol: FirNamedFunctionSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtSamConstructorSymbol(), KtFirSymbol<FirSimpleFunction> {
+) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    override val name: Name get() = firRef.withFir { it.name }
-    override val returnType: KtType by cached {
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
 
-    override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        fir.valueParameters.map { valueParameter ->
+
-            builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter)
+    override val valueParameters: List<KtValueParameterSymbol>
+        get() = withValidityAssertion {
+            firSymbol.fir.valueParameters.map { valueParameter ->
+                builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter.symbol)
+            }
         }
-    }
 
-    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
+    override val hasStableParameterNames: Boolean
+        get() = withValidityAssertion {
+            firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session)
+        }
 
-    override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
+    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
-    override val receiverType: KtType? by cached {
-        firRef.receiverType(builder)
-    }
 
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
+
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
 
     override fun createPointer(): KtSymbolPointer<KtSamConstructorSymbol> {
-        return firRef.withFir { fir ->
+        val callableId = firSymbol.callableId
-            val callableId = fir.symbol.callableId
+        return KtFirSamConstructorSymbolPointer(ClassId(callableId.packageName, callableId.callableName))
-            KtFirSamConstructorSymbolPointer(ClassId(callableId.packageName, callableId.callableName))
-        }
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbol.kt

@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
-import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
@@ -17,19 +17,22 @@ import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.originalIfFakeOverride
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 
-internal interface KtFirSymbol<out F : FirDeclaration> : KtSymbol, ValidityTokenOwner {
+internal interface KtFirSymbol<out S : FirBasedSymbol<*>> : KtSymbol, ValidityTokenOwner {
-    val firRef: FirRefWithValidityCheck<F>
+    val firSymbol: S
 
-    override val origin: KtSymbolOrigin get() = firRef.withFir { it.ktSymbolOrigin() }
+    abstract val resolveState: FirModuleResolveState
+
+    override val origin: KtSymbolOrigin get() = firSymbol.fir.ktSymbolOrigin()
 }
 
 internal fun KtFirSymbol<*>.symbolEquals(other: Any?): Boolean {
     if (other !is KtFirSymbol<*>) return false
-    return this.firRef == other.firRef
+    return this.firSymbol == other.firSymbol
 }
 
-internal fun KtFirSymbol<*>.symbolHashCode(): Int = firRef.hashCode()
+internal fun KtFirSymbol<*>.symbolHashCode(): Int = firSymbol.hashCode()
 
 internal tailrec fun FirDeclaration.ktSymbolOrigin(): KtSymbolOrigin = when (origin) {
     FirDeclarationOrigin.Source -> {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbolProvider.kt

@@ -15,12 +15,11 @@ import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclarationOfType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirSymbolOfType
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.analysis.api.symbols.KtClassInitializerSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -41,87 +40,87 @@ internal class KtFirSymbolProvider(
                 "Creating KtValueParameterSymbol for function type parameter is not possible. Please see the KDoc of getParameterSymbol"
             )
 
-            psi.isLoopParameter -> psi.withFirDeclarationOfType<FirProperty, KtLocalVariableSymbol>(resolveState) {
+            psi.isLoopParameter -> psi.withFirSymbolOfType<FirPropertySymbol, KtLocalVariableSymbol>(resolveState) {
                 firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(it)
             }
 
-            else -> psi.withFirDeclarationOfType<FirValueParameter, KtValueParameterSymbol>(resolveState) {
+            else -> psi.withFirSymbolOfType<FirValueParameterSymbol, KtValueParameterSymbol>(resolveState) {
                 firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(it)
             }
         }
     }
 
     override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
-        firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(resolveState))
+        firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(resolveState).symbol)
     }
 
     override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirFunction, KtFunctionLikeSymbol>(resolveState) { fir ->
+        psi.withFirSymbolOfType<FirFunctionSymbol<*>, KtFunctionLikeSymbol>(resolveState) { fir ->
             when (fir) {
-                is FirSimpleFunction -> {
+                is FirNamedFunctionSymbol -> {
                     if (fir.origin == FirDeclarationOrigin.SamConstructor) {
                         firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(fir)
                     } else {
                         firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(fir)
                     }
                 }
-                is FirAnonymousFunction -> firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(fir)
+                is FirAnonymousFunctionSymbol -> firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(fir)
-                else -> error("Unexpected ${fir.renderWithType()}")
+                else -> error("Unexpected ${fir.fir.renderWithType()}")
             }
         }
     }
 
     override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirConstructor, KtConstructorSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirConstructorSymbol, KtConstructorSymbol>(resolveState) {
             firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(it)
         }
     }
 
     override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirTypeParameter, KtTypeParameterSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirTypeParameterSymbol, KtTypeParameterSymbol>(resolveState) {
             firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(it)
         }
     }
 
     override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirTypeAlias, KtTypeAliasSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirTypeAliasSymbol, KtTypeAliasSymbol>(resolveState) {
             firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(it)
         }
     }
 
     override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirEnumEntry, KtEnumEntrySymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirEnumEntrySymbol, KtEnumEntrySymbol>(resolveState) {
             firSymbolBuilder.buildEnumEntrySymbol(it)
         }
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirSimpleFunction, KtFunctionSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirNamedFunctionSymbol, KtFunctionSymbol>(resolveState) {
             firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(it)
         }
         firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(resolveState))
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirAnonymousFunction, KtAnonymousFunctionSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirAnonymousFunctionSymbol, KtAnonymousFunctionSymbol>(resolveState) {
             firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(it)
         }
     }
 
     override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirProperty, KtVariableSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirPropertySymbol, KtVariableSymbol>(resolveState) {
             firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(it)
         }
     }
 
     override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
-        psi.objectDeclaration.withFirDeclarationOfType<FirAnonymousObject, KtAnonymousObjectSymbol>(resolveState) {
+        psi.objectDeclaration.withFirSymbolOfType<FirAnonymousObjectSymbol, KtAnonymousObjectSymbol>(resolveState) {
             firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol(it)
         }
     }
 
     override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirClass, KtClassOrObjectSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirClassSymbol<*>, KtClassOrObjectSymbol>(resolveState) {
             firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(it)
         }
     }
@@ -130,31 +129,31 @@ internal class KtFirSymbolProvider(
         require(psi !is KtObjectDeclaration || psi.parent !is KtObjectLiteralExpression)
         // A KtClassOrObject may also map to an FirEnumEntry. Hence, we need to return null in this case.
         if (psi is KtEnumEntry) return null
-        psi.withFirDeclarationOfType<FirRegularClass, KtNamedClassOrObjectSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirRegularClassSymbol, KtNamedClassOrObjectSymbol>(resolveState) {
             firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(it)
         }
     }
 
     override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirPropertyAccessor, KtPropertyAccessorSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirPropertyAccessorSymbol, KtPropertyAccessorSymbol>(resolveState) {
             firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(it)
         }
     }
 
     override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
-        psi.withFirDeclarationOfType<FirAnonymousInitializer, KtClassInitializerSymbol>(resolveState) {
+        psi.withFirSymbolOfType<FirAnonymousInitializerSymbol, KtClassInitializerSymbol>(resolveState) {
             firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer(it)
         }
     }
 
     override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? = withValidityAssertion {
         val symbol = firSymbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol ?: return null
-        firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(symbol.fir)
+        firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(symbol)
     }
 
     override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): Sequence<KtSymbol> {
         val firs = firSymbolProvider.getTopLevelCallableSymbols(packageFqName, name)
-        return firs.asSequence().map { firSymbol -> firSymbolBuilder.buildSymbol(firSymbol.fir) }
+        return firs.asSequence().map { firSymbol -> firSymbolBuilder.buildSymbol(firSymbol) }
     }
 
     override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol = KtFirPackageSymbol(FqName.ROOT, resolveState.project, token)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt

@@ -10,11 +10,8 @@ import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
-
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirJavaSyntheticPropertySymbolPointer
-import org.jetbrains.kotlin.analysis.api.fir.utils.asKtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
@@ -24,76 +21,75 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.containingClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
+import org.jetbrains.kotlin.fir.declarations.utils.modality
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
+import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSyntheticJavaPropertySymbol(
-    fir: FirSyntheticProperty,
+    override val firSymbol: FirSyntheticPropertySymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticProperty> {
+) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val isVal: Boolean get() = firRef.withFir { it.isVal }
+    override val isVal: Boolean get() = withValidityAssertion { firSymbol.isVal }
-    override val name: Name get() = firRef.withFir { it.name }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    override val returnType: KtType by cached {
-        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-    }
 
-    override val typeParameters: List<KtTypeParameterSymbol> by cached {
+    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
-        fir.typeParameters.map { builder.classifierBuilder.buildTypeParameterSymbol(it) }
+    override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
-    }
 
-    override val receiverType: KtType? by cached {
+    override val typeParameters: List<KtTypeParameterSymbol>
-        firRef.receiverType(builder)
+        get() = withValidityAssertion { firSymbol.createKtTypeParameters(builder) }
-    }
-    override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
-    override val initializer: KtInitializerValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir ->
-        fir.initializer?.asKtInitializerValue()
-    }
-
-    override val modality: Modality get() = getModality()
-    override val visibility: Visibility get() = getVisibility()
-
-        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
 
 
-    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
+    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }
 
-    override val getter: KtPropertyGetterSymbol by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { property ->
+    override val initializer: KtInitializerValue? by cached { firSymbol.getKtConstantInitializer() }
-        property.getter.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as KtPropertyGetterSymbol
+
-    }
+    override val modality: Modality get() = withValidityAssertion { firSymbol.modality ?: firSymbol.invalidModalityError() }
+    override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
+
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
+
+    override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
+
+    override val getter: KtPropertyGetterSymbol
+        get() = withValidityAssertion {
+            builder.callableBuilder.buildGetterSymbol(firSymbol.getterSymbol!!)
+        }
     override val javaGetterSymbol: KtFunctionSymbol
         get() {
-            return firRef.withFir { builder.functionLikeBuilder.buildFunctionSymbol(it.getter.delegate) }
+            val fir = firSymbol.fir as FirSyntheticProperty
+            return builder.functionLikeBuilder.buildFunctionSymbol(fir.getter.delegate.symbol)
         }
     override val javaSetterSymbol: KtFunctionSymbol?
         get() {
-            return firRef.withFir { fir ->
+            val fir = firSymbol.fir as FirSyntheticProperty
-                fir.setter?.delegate?.let { setter -> builder.functionLikeBuilder.buildFunctionSymbol(setter) }
+            return fir.setter?.delegate?.let { builder.functionLikeBuilder.buildFunctionSymbol(it.symbol) }
-            }
         }
 
-    override val setter: KtPropertySetterSymbol? by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { property ->
+    override val setter: KtPropertySetterSymbol?
-        property.setter?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertySetterSymbol
+        get() = withValidityAssertion {
-    }
+            firSymbol.setterSymbol?.let { builder.callableBuilder.buildPropertyAccessorSymbol(it) } as? KtPropertySetterSymbol
+        }
 
-    override val isFromPrimaryConstructor: Boolean get() = false
+    override val isFromPrimaryConstructor: Boolean get() = withValidityAssertion { false }
-    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
+    override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
-    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }
+    override val isStatic: Boolean get() = withValidityAssertion { firSymbol.isStatic }
 
-    override val hasSetter: Boolean get() = firRef.withFir { it.setter != null }
+    override val hasSetter: Boolean get() = withValidityAssertion { firSymbol.setterSymbol != null }
 
     override val origin: KtSymbolOrigin get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
 
     override fun createPointer(): KtSymbolPointer<KtSyntheticJavaPropertySymbol> {
-        val containingClassId = firRef.withFir { it.containingClass()?.classId }
+        val containingClassId = firSymbol.containingClass()?.classId
             ?: error("Cannot find parent class for synthetic java property $callableIdIfNonLocal")
 
         return KtFirJavaSyntheticPropertySymbolPointer(containingClassId, name)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeAliasSymbol.kt

@@ -7,58 +7,49 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.utils.isLocal
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
-import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeAliasSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.declarations.utils.visibility
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirTypeAliasSymbol(
-    fir: FirTypeAlias,
+    override val firSymbol: FirTypeAliasSymbol,
-    private val resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder,
-) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAlias> {
+) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> {
 
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
-    override val name: Name get() = firRef.withFir { it.name }
+    override val classIdIfNonLocal: ClassId? get() = withValidityAssertion { firSymbol.getClassIdIfNonLocal() }
-    override val classIdIfNonLocal: ClassId get() = firRef.withFir { it.symbol.classId }
 
     override val visibility: Visibility
-        get() = when (val possiblyRawVisibility = getVisibility(FirResolvePhase.RAW_FIR)) {
+        get() = withValidityAssertion {
-            Visibilities.Unknown -> Visibilities.Public
+            when (val possiblyRawVisibility = firSymbol.fir.visibility) {
-            else -> possiblyRawVisibility
+                Visibilities.Unknown -> Visibilities.Public
+                else -> possiblyRawVisibility
+            }
         }
 
-    override val typeParameters by firRef.withFirAndCache { fir ->
+    override val typeParameters by cached { firSymbol.createKtTypeParameters(builder) }
-        fir.typeParameters.filterIsInstance<FirTypeParameter>().map { typeParameter ->
-            builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol.fir)
-        }
-    }
 
-    override val expandedType: KtType by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir ->
+    override val expandedType: KtType by cached { builder.typeBuilder.buildKtType(firSymbol.resolvedExpandedTypeRef) }
-        builder.typeBuilder.buildKtType(fir.expandedTypeRef)
-    }
 
     override val annotationsList: KtAnnotationsList by cached {
-        KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token)
+        KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token)
     }
 
     override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> {

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

@@ -6,27 +6,26 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
-import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.transformers.resolveSupertypesInTheAir
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 
-internal fun FirRefWithValidityCheck<FirClass>.superTypesList(builder: KtSymbolByFirBuilder): List<KtType> =
+internal fun FirClassSymbol<*>.superTypesList(builder: KtSymbolByFirBuilder): List<KtType> =
-    withFir(FirResolvePhase.SUPER_TYPES) { fir ->
+    resolvedSuperTypeRefs.mapToKtType(builder)
-        fir.superTypeRefs.mapToKtType(builder)
+
+internal fun FirRegularClassSymbol.superTypesAndAnnotationsListForRegularClass(builder: KtSymbolByFirBuilder): List<KtType> {
+    val fir = fir
+
+    if (fir.resolvePhase >= FirResolvePhase.SUPER_TYPES) {
+        return fir.superTypeRefs.mapToKtType(builder)
     }
 
-internal fun FirRefWithValidityCheck<FirRegularClass>.superTypesAndAnnotationsListForRegularClass(builder: KtSymbolByFirBuilder): List<KtType> {
+    return fir.resolveSupertypesInTheAir(builder.rootSession).mapToKtType(builder)
-    return withFir { fir ->
-        if (fir.resolvePhase >= FirResolvePhase.SUPER_TYPES) {
-            fir.superTypeRefs.mapToKtType(builder)
-        } else null
-    } ?: withFirByType(ResolveType.NoResolve) { fir ->
-        fir.resolveSupertypesInTheAir(builder.rootSession).mapToKtType(builder)
-    }
 }
 
 private fun List<FirTypeRef>.mapToKtType(
@@ -35,15 +34,11 @@ private fun List<FirTypeRef>.mapToKtType(
     builder.typeBuilder.buildKtType(typeRef)
 }
 
-internal fun FirRefWithValidityCheck<FirTypedDeclaration>.returnType(
+internal fun FirCallableSymbol<*>.returnType(builder: KtSymbolByFirBuilder): KtType =
-    typeResolvePhase: FirResolvePhase,
+    builder.typeBuilder.buildKtType(resolvedReturnType)
-    builder: KtSymbolByFirBuilder
-) = withFir(typeResolvePhase) { builder.typeBuilder.buildKtType(it.returnTypeRef) }
 
-internal fun FirRefWithValidityCheck<FirCallableDeclaration>.receiverType(
+internal fun FirCallableSymbol<*>.receiverType(builder: KtSymbolByFirBuilder): KtType? =
-    builder: KtSymbolByFirBuilder
+    resolvedReceiverTypeRef?.let { receiver ->
-): KtType? = withFir(FirResolvePhase.TYPES) { fir ->
-    fir.receiverTypeRef?.let { receiver ->
         builder.typeBuilder.buildKtType(receiver)
     }
-}
+

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeParameterSymbol.kt

@@ -6,38 +6,36 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
+import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
+import org.jetbrains.kotlin.analysis.api.fir.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
 
 internal class KtFirTypeParameterSymbol(
-    fir: FirTypeParameter,
+    override val firSymbol: FirTypeParameterSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameter> {
+) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val name: Name get() = firRef.withFir { it.name }
+    override val name: Name get() = withValidityAssertion { firSymbol.name }
 
-    override val upperBounds: List<KtType> by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir ->
+    override val upperBounds: List<KtType> by cached {
-        fir.bounds.map { type -> builder.typeBuilder.buildKtType(type) }
+        firSymbol.resolvedBounds.map { type -> builder.typeBuilder.buildKtType(type) }
     }
 
-    override val variance: Variance get() = firRef.withFir { it.variance }
+    override val variance: Variance get() = withValidityAssertion { firSymbol.variance }
-    override val isReified: Boolean get() = firRef.withFir { it.isReified }
+    override val isReified: Boolean get() = withValidityAssertion { firSymbol.isReified }
 
     override fun createPointer(): KtSymbolPointer<KtTypeParameterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirValueParameterSymbol.kt

@@ -10,27 +10,25 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.getAnnotationsByClassId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.FirConstExpression
 import org.jetbrains.kotlin.fir.expressions.unwrapArgument
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderWithType
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 import org.jetbrains.kotlin.fir.types.arrayElementType
-import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.customAnnotations
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -39,68 +37,32 @@ import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 internal class KtFirValueParameterSymbol(
-    fir: FirValueParameter,
+    override val firSymbol: FirValueParameterSymbol,
-    resolveState: FirModuleResolveState,
+    override val resolveState: FirModuleResolveState,
     override val token: ValidityToken,
     private val builder: KtSymbolByFirBuilder
-) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameter> {
+) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> {
-    override val firRef = firRef(fir, resolveState)
+    override val psi: PsiElement? by cached { firSymbol.findPsi() }
-    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val name: Name by cached {
+    override val name: Name by cached { firSymbol.getNameByAnnotation(resolveState) }
-        firRef.withFir { fir ->
-            val defaultName = fir.name
-            if (fir.psi != null) return@withFir defaultName
 
-            // The case where PSI is null is when calling `invoke()` on a variable with functional type, e.g. `x(1)` below:
+    override val isVararg: Boolean get() = withValidityAssertion { firSymbol.isVararg }
-            //
-            //   fun foo(x: (item: Int) -> Unit) { x(1) }
-            //   fun bar(x: Function1<@ParameterName("item") Int, Unit>) { x(1) }
-            //
-            // The function being called is `invoke(p1: Int)` on `Function1<Int, Unit>` which is from the stdlib, and therefore no source
-            // PSI for the function or its parameters. In that case, we use the `@ParameterName` annotation on the parameter type if present
-            // and fall back to the parameter names from the `invoke()` function (`p1`, `p2`, etc.).
-            //
-            // Note: During type resolution, `@ParameterName` type annotations are added based on the names (which are optional) in the
-            // function type notation. Therefore the `x` parameter in both example functions above have the same type and type annotations.
-            fir.withFirDeclaration(resolveState, FirResolvePhase.TYPES) {
-                val parameterNameAnnotation =
-                    fir.returnTypeRef.coneType.attributes.customAnnotations
-                        .getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId)
-                        .singleOrNull()?.safeAs<FirAnnotation>() ?: return@withFirDeclaration defaultName
 
-                // The parent KtDeclaration is where the variable with functional type and `@ParameterName` annotation is declared.
+    override val returnType by cached {
-                val parentKtDeclaration =
+        val returnType = firSymbol.resolvedReturnType
-                    parameterNameAnnotation.psi?.getNonStrictParentOfType<KtDeclaration>() ?: return@withFirDeclaration defaultName
+        return@cached if (firSymbol.isVararg) {
-                val parentFirDeclaration = parentKtDeclaration.getOrBuildFirOfType<FirDeclaration>(resolveState)
-
-                // Resolve to ARGUMENTS_OF_ANNOTATIONS phase to get `name` argument from mapping.
-                val parameterNameFromAnnotation =
-                    parentFirDeclaration.withFirDeclaration(resolveState, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
-                        val nameArgument =
-                            parameterNameAnnotation.argumentMapping.mapping[StandardClassIds.Annotations.ParameterNames.parameterNameName]
-                        nameArgument?.unwrapArgument()?.safeAs<FirConstExpression<*>>()?.value as? String
-                    }
-                parameterNameFromAnnotation?.let { Name.identifier(it) } ?: defaultName
-            }
-        }
-    }
-
-    override val isVararg: Boolean get() = firRef.withFir { it.isVararg }
-    override val returnType: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir ->
-        if (fir.isVararg) {
             // There SHOULD always be an array element type (even if it is an error type, e.g., unresolved).
-            val arrayElementType = fir.returnTypeRef.coneType.arrayElementType()
+            val arrayElementType = returnType.arrayElementType()
-                ?: error("No array element type for vararg value parameter: ${fir.renderWithType()}")
+                ?: error("No array element type for vararg value parameter: ${firSymbol.fir.renderWithType()}")
             builder.typeBuilder.buildKtType(arrayElementType)
         } else {
-            firRef.returnType(FirResolvePhase.TYPES, builder)
+            builder.typeBuilder.buildKtType(returnType)
         }
     }
 
-    override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null }
+    override val hasDefaultValue: Boolean get() = withValidityAssertion { firSymbol.hasDefaultValue }
 
-    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.rootModuleSession, token) }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
@@ -110,3 +72,36 @@ internal class KtFirValueParameterSymbol(
     override fun equals(other: Any?): Boolean = symbolEquals(other)
     override fun hashCode(): Int = symbolHashCode()
 }
+
+
+private fun FirValueParameterSymbol.getNameByAnnotation(resolveState: FirModuleResolveState): Name {
+    val defaultName = fir.name
+    if (fir.psi != null) return defaultName
+
+    // The case where PSI is null is when calling `invoke()` on a variable with functional type, e.g. `x(1)` below:
+    //
+    //   fun foo(x: (item: Int) -> Unit) { x(1) }
+    //   fun bar(x: Function1<@ParameterName("item") Int, Unit>) { x(1) }
+    //
+    // The function being called is `invoke(p1: Int)` on `Function1<Int, Unit>` which is from the stdlib, and therefore no source
+    // PSI for the function or its parameters. In that case, we use the `@ParameterName` annotation on the parameter type if present
+    // and fall back to the parameter names from the `invoke()` function (`p1`, `p2`, etc.).
+    //
+    // Note: During type resolution, `@ParameterName` type annotations are added based on the names (which are optional) in the
+    // function type notation. Therefore the `x` parameter in both example functions above have the same type and type annotations.
+    val parameterNameAnnotation =
+        resolvedReturnType.attributes.customAnnotations
+            .getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId)
+            .singleOrNull()?.safeAs<FirAnnotation>() ?: return defaultName
+
+    // The parent KtDeclaration is where the variable with functional type and `@ParameterName` annotation is declared.
+    val parentKtDeclaration =
+        parameterNameAnnotation.psi?.getNonStrictParentOfType<KtDeclaration>() ?: return defaultName
+    val parentFirDeclaration = parentKtDeclaration.getOrBuildFirOfType<FirDeclaration>(resolveState)
+
+    // Resolve to ARGUMENTS_OF_ANNOTATIONS phase to get `name` argument from mapping.
+    parentFirDeclaration.ensureResolved(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+    val nameArgument = parameterNameAnnotation.argumentMapping.mapping[StandardClassIds.Annotations.ParameterNames.parameterNameName]
+    val parameterNameFromAnnotation = nameArgument?.unwrapArgument()?.safeAs<FirConstExpression<*>>()?.value as? String
+    return parameterNameFromAnnotation?.let { Name.identifier(it) } ?: defaultName
+}

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/firSymbolUtils.kt

@@ -5,47 +5,68 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
-import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.analysis.api.KtInitializerValue
-import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.utils.asKtInitializerValue
+import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
-import org.jetbrains.kotlin.fir.declarations.utils.modality
-import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderWithType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtDeclaration
 
-internal fun KtFirSymbol<FirMemberDeclaration>.getModality(
-    phase: FirResolvePhase = FirResolvePhase.STATUS,
-    defaultModality: Modality? = null
-): Modality {
-    return firRef.withFir(phase) { fir ->
-        fir.modality
-            ?: defaultModality
-            ?: fir.invalidModalityError()
-    }
-}
 
-private fun FirDeclaration.invalidModalityError(): Nothing {
+internal fun FirCallableSymbol<*>.invalidModalityError(): Nothing {
     error(
         """|Symbol modality should not be null, looks like the FIR symbol was not properly resolved
                    |
-                   |${renderWithType(FirRenderer.RenderMode.WithResolvePhases)}
+                   |${fir.renderWithType(FirRenderer.RenderMode.WithResolvePhases)}
                    |
-                   |${(psi as? KtDeclaration)?.getElementTextInContext()}""".trimMargin()
+                   |${(fir.psi as? KtDeclaration)?.getElementTextInContext()}""".trimMargin()
     )
 }
 
+internal fun FirFunctionSymbol<*>.createKtValueParameters(builder: KtSymbolByFirBuilder): List<KtValueParameterSymbol> {
+    return fir.valueParameters.map { valueParameter ->
+        builder.variableLikeBuilder.buildValueParameterSymbol(valueParameter.symbol)
+    }
+}
 
-internal fun KtFirSymbol<FirMemberDeclaration>.getVisibility(
+internal fun <D> FirBasedSymbol<D>.createKtTypeParameters(
-    phase: FirResolvePhase = FirResolvePhase.STATUS
+    builder: KtSymbolByFirBuilder
-): Visibility =
+): List<KtFirTypeParameterSymbol> where D : FirTypeParameterRefsOwner, D : FirDeclaration {
-    firRef.withFir(phase) { fir -> fir.visibility }
+    return fir.typeParameters.map { typeParameter ->
+        builder.classifierBuilder.buildTypeParameterSymbol(typeParameter.symbol)
+    }
+}
 
-internal fun KtFirSymbol<FirCallableDeclaration>.getCallableIdIfNonLocal(): CallableId? =
+
-    firRef.withFir { fir -> fir.symbol.callableId.takeUnless { it.isLocal } }
+internal fun FirCallableSymbol<*>.getCallableIdIfNonLocal(): CallableId? =
+    callableId.takeUnless { it.isLocal }
+
+internal fun FirClassLikeSymbol<*>.getClassIdIfNonLocal(): ClassId? =
+    classId.takeUnless { it.isLocal }
+
+internal fun FirCallableSymbol<*>.dispatchReceiverType(
+    builder: KtSymbolByFirBuilder,
+): KtType? {
+    return dispatchReceiverType?.let { builder.typeBuilder.buildKtType(it) }
+}
+
+internal fun FirVariableSymbol<*>.getKtConstantInitializer(): KtInitializerValue? {
+    ensureResolved(FirResolvePhase.BODY_RESOLVE)
+    val firInitializer = fir.initializer ?: return null
+    return firInitializer.asKtInitializerValue()
+}

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirBackingFieldSymbolPointer.kt

@@ -21,9 +21,7 @@ internal class KtFirBackingFieldSymbolPointer(
         @Suppress("DEPRECATION")
         val propertySymbol = propertySymbolPointer.restoreSymbol(analysisSession) ?: return null
         check(propertySymbol is KtFirKotlinPropertySymbol)
-        return propertySymbol.firRef.withFir { firProperty ->
+        return analysisSession.firSymbolBuilder.variableLikeBuilder.buildBackingFieldSymbolByProperty(propertySymbol.firSymbol)
-            analysisSession.firSymbolBuilder.variableLikeBuilder.buildBackingFieldSymbolByProperty(firProperty)
-        }
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirConstructorSymbolPointer.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.ClassId
 
@@ -26,7 +26,7 @@ internal class KtFirConstructorSymbolPointer(
             candidates.findDeclarationWithSignature<FirConstructor>(signature, firSession) { processDeclaredConstructors(it) }
                 ?: return null
         if (firConstructor.isPrimary != isPrimary) return null
-        return firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(firConstructor)
+        return firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(firConstructor.symbol)
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirEnumEntrySymbolPointer.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -26,7 +26,7 @@ internal class KtFirEnumEntrySymbolPointer(
             ?: return null
         val enumEntry = enumClass.enumEntryByName(name)
             ?: return null
-        return analysisSession.firSymbolBuilder.buildEnumEntrySymbol(enumEntry)
+        return analysisSession.firSymbolBuilder.buildEnumEntrySymbol(enumEntry.symbol)
     }
 
     private fun getEnumClass(analysisSession: KtFirAnalysisSession, classId: ClassId): FirRegularClass? {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirJavaFieldSymbolPointer.kt

@@ -28,6 +28,6 @@ internal class KtFirJavaFieldSymbolPointer(
                 .singleOrNull()
                 ?: return null
 
-        return firSymbolBuilder.variableLikeBuilder.buildFieldSymbol(javaField)
+        return firSymbolBuilder.variableLikeBuilder.buildFieldSymbol(javaField.symbol)
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirJavaSyntheticPropertySymbolPointer.kt

@@ -28,6 +28,6 @@ internal class KtFirJavaSyntheticPropertySymbolPointer(
                 .singleOrNull()
                 ?: return null
 
-        return firSymbolBuilder.variableLikeBuilder.buildSyntheticJavaPropertySymbol(syntheticProperty)
+        return firSymbolBuilder.variableLikeBuilder.buildSyntheticJavaPropertySymbol(syntheticProperty.symbol)
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirMemberFunctionSymbolPointer.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -26,7 +26,7 @@ internal class KtFirMemberFunctionSymbolPointer(
         val firFunction = candidates.findDeclarationWithSignature<FirSimpleFunction>(signature, firSession) {
             processFunctionsByName(name, it)
         } ?: return null
-        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firFunction)
+        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firFunction.symbol)
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirMemberPropertySymbolPointer.kt

@@ -5,12 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -26,7 +25,7 @@ internal class KtFirMemberPropertySymbolPointer(
     ): KtKotlinPropertySymbol? {
         val firProperty = candidates.findDeclarationWithSignature<FirProperty>(signature, firSession) { processPropertiesByName(name, it) }
             ?: return null
-        return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(firProperty) as? KtKotlinPropertySymbol
+        return firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(firProperty.symbol) as? KtKotlinPropertySymbol
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirMemberSymbolPointer.kt

@@ -5,15 +5,15 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.name.ClassId
 
 internal abstract class KtFirMemberSymbolPointer<S : KtSymbol>(

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirSamConstructorSymbolPointer.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirSamConstructorSymbolPointer(
@@ -19,7 +19,7 @@ internal class KtFirSamConstructorSymbolPointer(
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtSamConstructorSymbol? {
         require(analysisSession is KtFirAnalysisSession)
         val owner = analysisSession.getClassLikeSymbol(ownerClassId) as? FirRegularClass ?: return null
-        val classSymbol = analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(owner)
+        val classSymbol = analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(owner.symbol)
         with(analysisSession) {
             return classSymbol.getSamConstructor()
         }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirTopLevelFunctionSymbolPointer.kt

@@ -5,15 +5,13 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.symbols.pointers
 
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirTopLevelFunctionSymbolPointer(
     callableId: CallableId,
@@ -24,7 +22,7 @@ internal class KtFirTopLevelFunctionSymbolPointer(
         firSession: FirSession
     ): KtFunctionSymbol? {
         val firFunction = candidates.findDeclarationWithSignatureBySymbols<FirSimpleFunction>(signature, firSession) ?: return null
-        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firFunction)
+        return firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firFunction.symbol)
     }
 }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/pointerUtils.kt

@@ -48,6 +48,9 @@ internal inline fun <reified D : FirDeclaration> Collection<FirCallableSymbol<*>
     return null
 }
 
+internal fun FirBasedSymbol<*>.createSignature(): IdSignature =
+    fir.createSignature()
+
 internal fun FirDeclaration.createSignature(): IdSignature {
     val signatureComposer = moduleData.session.ideSessionComponents.signatureComposer
     return signatureComposer.composeSignature(this)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/FirKtType.kt

@@ -18,8 +18,6 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.*
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
-import org.jetbrains.kotlin.fir.types.isSuspendFunctionType
-import org.jetbrains.kotlin.fir.types.receiverType
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -132,7 +130,7 @@ internal class KtFirClassErrorType(
 
     override val candidateClassSymbols: Collection<KtClassLikeSymbol> by cached {
         val symbols = coneType.diagnostic.getCandidateSymbols().filterIsInstance<FirClassLikeSymbol<*>>()
-        symbols.map { builder.classifierBuilder.buildClassLikeSymbol(it.fir) }
+        symbols.map { builder.classifierBuilder.buildClassLikeSymbol(it) }
     }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }

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

@@ -1,66 +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.api.fir.utils
-
-import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.api.tokens.assertIsValidAndAccessible
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-
-internal class FirRefWithValidityCheck<out D : FirDeclaration>(
-    private val fir: D,
-    val resolveState: FirModuleResolveState,
-    val token: ValidityToken
-) {
-
-    inline fun <R> withFir(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, crossinline action: (fir: D) -> R): R {
-        token.assertIsValidAndAccessible()
-        return fir.withFirDeclaration(resolveState, phase) { action(it) }
-    }
-
-    /**
-     * Runs [action] with fir element *without* any lock hold
-     * Consider using this only when you are completely sure
-     * that fir or one of it's container already holds the lock (i.e, corresponding withFir call was made)
-     */
-    inline fun <R> withFirUnsafe(action: (fir: D) -> R): R {
-        token.assertIsValidAndAccessible()
-        return action(fir)
-    }
-
-    inline fun <R> withFirAndCache(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, crossinline createValue: (fir: D) -> R) =
-        ValidityAwareCachedValue(token) {
-            withFir(phase) { fir -> createValue(fir) }
-        }
-
-    inline fun <R> withFirByType(type: ResolveType, crossinline action: (fir: D) -> R): R {
-        token.assertIsValidAndAccessible()
-        return fir.withFirDeclaration(type, resolveState) { action(it) }
-    }
-
-    inline fun <R> withFirAndCache(type: ResolveType, crossinline createValue: (fir: D) -> R) =
-        ValidityAwareCachedValue(token) {
-            withFirByType(type) { fir -> createValue(fir) }
-        }
-
-    override fun equals(other: Any?): Boolean {
-        if (other !is FirRefWithValidityCheck<*>) return false
-        return fir == other.fir && this.token == other.token
-    }
-
-    override fun hashCode(): Int {
-        return fir.hashCode() * 31 + token.hashCode()
-    }
-
-}
-
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun <D : FirDeclaration> ValidityTokenOwner.firRef(fir: D, resolveState: FirModuleResolveState) =
-    FirRefWithValidityCheck(fir, resolveState, token)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt

@@ -5,11 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
@@ -20,6 +15,11 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.psi.KtElement
 
@@ -32,7 +32,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
     val firResolveState: FirModuleResolveState get() = firAnalysisSession.firResolveState
 
     fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol =
-        firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir)
+        firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir.symbol)
 
     fun buildKtType(coneType: FirTypeRef): KtType =
         firAnalysisSession.firSymbolBuilder.typeBuilder.buildKtType(coneType)
@@ -41,9 +41,9 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
 
     @Suppress("UNCHECKED_CAST", "NON_PUBLIC_CALL_FROM_PUBLIC_INLINE")
     inline fun <T : FirDeclaration, R> withFir(ktSymbol: KtSymbol, crossinline action: (T) -> R) =
-        (ktSymbol as KtFirSymbol<T>).firRef.withFir(action = action)
+        (ktSymbol as KtFirSymbol<*>).firSymbol.fir.let { action(it as T) }
 
-    fun toSignature(ktSymbol: KtSymbol): IdSignature = (ktSymbol as KtFirSymbol<*>).firRef.withFir { it.createSignature() }
+    fun toSignature(ktSymbol: KtSymbol): IdSignature = (ktSymbol as KtFirSymbol<*>).firSymbol.createSignature()
 
     companion object {
         @InvalidWayOfUsingAnalysisSession

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/LazyOnlyWeakRef.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import java.lang.ref.WeakReference
 import kotlin.reflect.KProperty
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ValidityAwareCachedValue.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.tokens.assertIsValidAndAccessible
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/firUtils.kt

@@ -9,25 +9,29 @@ import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
+import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
+import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
-import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.fir.types.ConeClassErrorType
-import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.fir.types.ConeNullability
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
+import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
-import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtVariableLikeSymbol.kt

@@ -54,6 +54,8 @@ public abstract class KtEnumEntrySymbol : KtVariableLikeSymbol(), KtSymbolWithMe
     final override val symbolKind: KtSymbolKind get() = KtSymbolKind.CLASS_MEMBER
     final override val isExtension: Boolean get() = false
     final override val receiverType: KtType? get() = null
+
+    //todo reduntant, remove
     public abstract val containingEnumClassIdIfNonLocal: ClassId?
 
     abstract override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol>

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

@@ -61,7 +61,7 @@ private fun collectDesignationPath(declaration: FirDeclaration): List<FirDeclara
             if (declaration.symbol.callableId.isLocal) return null
             if ((declaration as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null
             when (declaration) {
-                is FirSimpleFunction, is FirProperty, is FirField, is FirConstructor -> {
+                is FirSimpleFunction, is FirProperty, is FirField, is FirConstructor, is FirEnumEntry -> {
                     val klass = declaration.containingClass() ?: return emptyList()
                     if (klass.classId.isLocal) return null
                     @OptIn(LookupTagInternals::class)
@@ -90,7 +90,8 @@ fun FirDeclaration.collectDesignation(): FirDeclarationDesignation =
     tryCollectDesignation() ?: error("No designation of local declaration ${this.render()}")
 
 fun FirDeclaration.collectDesignationWithFile(): FirDeclarationDesignationWithFile =
-    tryCollectDesignationWithFile() ?: error("No designation of local declaration ${this.render()}")
+    tryCollectDesignationWithFile()
+        ?: error("No designation of local declaration ${this.render()}")
 
 fun FirDeclaration.tryCollectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile? =
     collectDesignationPath(this)?.let {

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

@@ -11,33 +11,33 @@ import java.util.*
 import kotlin.reflect.KClass
 
 class InvalidFirElementTypeException(
-    actualFirClass: KClass<out FirElement>?,
+    actualFirClass: KClass<*>?,
     ktElement: KtElement?,
-    expectedFirClasses: List<KClass<out FirElement>>,
+    expectedFirClasses: List<KClass<*>>,
 ) : IllegalStateException() {
     override val message: String = buildString {
         if (ktElement != null) {
             append("For $ktElement with text `${ktElement.text}`, ")
         }
         val message = when (expectedFirClasses.size) {
-            0 -> "Unexpected FirElement of type:"
+            0 -> "Unexpected element of type:"
-            1 -> "The FirElement of type ${expectedFirClasses.single()} expected, but"
+            1 -> "The element of type ${expectedFirClasses.single()} expected, but"
-            else -> "One of [${expectedFirClasses.joinToString()}] FirElement types expected, but"
+            else -> "One of [${expectedFirClasses.joinToString()}] element types expected, but"
         }
         append(if (ktElement == null) message else message.replaceFirstChar { it.lowercase(Locale.getDefault()) })
         if (actualFirClass != null) {
             append(" ${actualFirClass.simpleName} found")
         } else {
-            append(" no FirElement found")
+            append(" no element found")
         }
     }
 }
 
 
 fun throwUnexpectedFirElementError(
-    firElement: FirElement?,
+    firElement: Any?,
     ktElement: KtElement? = null,
-    vararg expectedFirClasses: KClass<out FirElement>
+    vararg expectedFirClasses: KClass<*>
 ): Nothing {
     throw InvalidFirElementTypeException(firElement?.let { it::class }, ktElement, expectedFirClasses.toList())
 }

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
@@ -43,10 +44,10 @@ fun KtModule.getResolveState(project: Project): FirModuleResolveState =
  * Otherwise, some threading problems may arise,
  */
 @OptIn(InternalForInline::class)
-inline fun <R> KtDeclaration.withFirDeclaration(
+inline fun <R> KtDeclaration.withFirSymbol(
     resolveState: FirModuleResolveState,
     phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
-    action: (FirDeclaration) -> R
+    action: (FirBasedSymbol<*>) -> R
 ): R {
     val firDeclaration = if (getKtModule(project) !is KtSourceModule) {
         resolveState.findSourceFirCompiledDeclaration(this)
@@ -60,7 +61,7 @@ inline fun <R> KtDeclaration.withFirDeclaration(
         firDeclaration
     }
 
-    return action(resolvedDeclaration)
+    return action(resolvedDeclaration.symbol)
 }
 
 /**
@@ -71,14 +72,14 @@ inline fun <R> KtDeclaration.withFirDeclaration(
  * Otherwise, some threading problems may arise,
  */
 @OptIn(InternalForInline::class)
-inline fun <R> KtDeclaration.withFirDeclaration(
+inline fun <R> KtDeclaration.withFirSymbolDeclaration(
     resolveState: FirModuleResolveState,
     resolveType: ResolveType = ResolveType.NoResolve,
-    action: (FirDeclaration) -> R
+    action: (FirBasedSymbol<*>) -> R
 ): R {
     val firDeclaration = resolveState.findSourceFirDeclaration(this)
     val resolvedDeclaration = firDeclaration.resolvedFirToType(resolveType, resolveState)
-    return action(resolvedDeclaration)
+    return action(resolvedDeclaration.symbol)
 }
 
 /**
@@ -91,11 +92,11 @@ inline fun <R> KtDeclaration.withFirDeclaration(
  * Otherwise, some threading problems may arise,
  */
 @OptIn(InternalForInline::class)
-inline fun <reified F : FirDeclaration, R> KtDeclaration.withFirDeclarationOfType(
+inline fun <reified F : FirBasedSymbol<*>, R> KtDeclaration.withFirSymbolOfType(
     resolveState: FirModuleResolveState,
     phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
     action: (F) -> R
-): R = withFirDeclaration(resolveState, phase) { firDeclaration ->
+): R = withFirSymbol(resolveState, phase) { firDeclaration ->
     if (firDeclaration !is F) throwUnexpectedFirElementError(firDeclaration, this, F::class)
     action(firDeclaration)
 }
@@ -164,7 +165,7 @@ fun KtFile.collectDiagnosticsForFile(
 /**
  * Resolves a given [FirDeclaration] to [phase] and returns resolved declaration
  *
- * Should not be called form [withFirDeclaration], [withFirDeclarationOfType] functions, as it it may cause deadlock
+ * Should not be called form [withFirSymbol], [withFirDeclarationOfType] functions, as it it may cause deadlock
  */
 fun <D : FirDeclaration> D.resolvedFirToPhase(
     phase: FirResolvePhase,
@@ -175,7 +176,7 @@ fun <D : FirDeclaration> D.resolvedFirToPhase(
 /**
  * Resolves a given [FirDeclaration] to [phase] and returns resolved declaration
  *
- * Should not be called form [withFirDeclaration], [withFirDeclarationOfType] functions, as it it may cause deadlock
+ * Should not be called form [withFirSymbol], [withFirDeclarationOfType] functions, as it it may cause deadlock
  */
 fun <D : FirDeclaration> D.resolvedFirToType(
     type: ResolveType,

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

@@ -129,7 +129,6 @@ internal inline fun PsiElement.getNonLocalContainingOrThisDeclaration(predicate:
             && (container.isNonAnonymousClassOrObject() || container is KtDeclarationWithBody || container is KtProperty || container is KtTypeAlias)
             && container !is KtPrimaryConstructor
             && declarationCanBeLazilyResolved(container)
-            && container !is KtEnumEntry
             && container !is KtFunctionLiteral
             && container.containingClassOrObject !is KtEnumEntry
             && predicate(container)

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyDeclarationResolver.kt

@@ -29,6 +29,10 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassBody
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
 
 internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBuilder) {
     /**
@@ -291,7 +295,8 @@ internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBui
             val nonLocalDeclaration = possiblyLocalDeclaration.getNonLocalContainingOrThisDeclaration()
                 ?: error("Container for local declaration cannot be null")
 
-            isLocalDeclarationResolveRequested = possiblyLocalDeclaration != nonLocalDeclaration
+            isLocalDeclarationResolveRequested =
+                possiblyLocalDeclaration != nonLocalDeclaration
             if (isLocalDeclarationResolveRequested && skipLocalDeclaration) return firDeclarationToResolve
 
             val nonLocalFirDeclaration = nonLocalDeclaration.findSourceNonLocalFirDeclaration(
@@ -428,4 +433,10 @@ internal class FirLazyDeclarationResolver(private val firFileBuilder: FirFileBui
     }
 }
 
+private fun KtDeclaration.isMemberOfEnumEntry(container: KtDeclaration) : Boolean {
+    if (container !is KtClass) return false
+    if (!container.isEnum()) return false
+    val enumEntryBody = this.parent as? KtClassBody ?: return false
+    return enumEntryBody.parent == container
+}
 

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

@@ -92,7 +92,6 @@ internal val FirDeclaration.containingKtFileIfAny: KtFile?
 internal fun KtDeclaration.isNonAnonymousClassOrObject() =
     this is KtClassOrObject
             && !this.isObjectLiteral()
-            && this !is KtEnumEntry
 
 
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirSymbolStatusUtils.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 // ---------------------- callables with status ----------------------
 
 inline val FirCallableSymbol<*>.modality: Modality? get() = resolvedStatus.modality
+inline val FirCallableSymbol<*>.modalityOrFinal: Modality get() = modality ?: Modality.FINAL
 inline val FirCallableSymbol<*>.isAbstract: Boolean get() = resolvedStatus.modality == Modality.ABSTRACT
 inline val FirCallableSymbol<*>.isOpen: Boolean get() = resolvedStatus.modality == Modality.OPEN
 inline val FirCallableSymbol<*>.isFinal: Boolean

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt

@@ -9,7 +9,11 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.name.ClassId
 
 abstract class FirBasedSymbol<E : FirDeclaration> {
     private var _fir: E? = null
@@ -34,6 +38,18 @@ abstract class FirBasedSymbol<E : FirDeclaration> {
 
     val annotations: List<FirAnnotation>
         get() = fir.annotations
+
+    val resolvedAnnotationsWithArguments: List<FirAnnotation>
+        get() {
+            ensureResolved(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
+            return fir.annotations
+        }
+
+    val resolvedAnnotationClassIds: List<ClassId>
+        get() {
+            ensureResolved(FirResolvePhase.TYPES)
+            return fir.annotations.mapNotNull { (it.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.classId }
+        }
 }
 
 @RequiresOptIn

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt

@@ -21,6 +21,10 @@ abstract class FirCallableSymbol<D : FirCallableDeclaration> : FirBasedSymbol<D>
             return fir.returnTypeRef as FirResolvedTypeRef
         }
 
+    val resolvedReturnType: ConeKotlinType
+        get() = resolvedReturnTypeRef.coneType
+
+
     val resolvedReceiverTypeRef: FirResolvedTypeRef?
         get() {
             ensureType(fir.receiverTypeRef)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt

@@ -10,10 +10,11 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.SpecialNames
 
 sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration>(
@@ -21,6 +22,8 @@ sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration>(
 ) : FirClassifierSymbol<D>() {
     abstract override fun toLookupTag(): ConeClassLikeLookupTag
 
+    val name get() = classId.shortClassName
+
     val deprecation: DeprecationsPerUseSite?
         get() {
             ensureResolved(FirResolvePhase.STATUS)
@@ -44,6 +47,9 @@ sealed class FirClassSymbol<C : FirClass>(classId: ClassId) : FirClassLikeSymbol
             return fir.superTypeRefs as List<FirResolvedTypeRef>
         }
 
+    val resolvedSuperTypes: List<ConeKotlinType>
+        get() = resolvedSuperTypeRefs.map { it.coneType }
+
     val declarationSymbols: List<FirBasedSymbol<*>>
         get() {
             return fir.declarations.map { it.symbol }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt

@@ -105,6 +105,9 @@ class FirAnonymousFunctionSymbol : FirFunctionWithoutNameSymbol<FirAnonymousFunc
     val label: FirLabel? get() = fir.label
 }
 
-class FirPropertyAccessorSymbol : FirFunctionWithoutNameSymbol<FirPropertyAccessor>(Name.identifier("accessor"))
+class FirPropertyAccessorSymbol : FirFunctionWithoutNameSymbol<FirPropertyAccessor>(Name.identifier("accessor")) {
+    val isGetter: Boolean get() = fir.isGetter
+    val isSetter: Boolean get() = fir.isSetter
+}
 
 class FirErrorFunctionSymbol : FirFunctionWithoutNameSymbol<FirErrorFunction>(Name.identifier("error"))

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt

@@ -30,6 +30,12 @@ open class FirPropertySymbol(
     val setterSymbol: FirPropertyAccessorSymbol?
         get() = fir.setter?.symbol
 
+    val backingFieldSymbol: FirBackingFieldSymbol?
+        get() = fir.backingField?.symbol
+
+    val delegateFieldSymbol: FirDelegateFieldSymbol?
+        get() = fir.delegateFieldSymbol
+
     val hasInitializer: Boolean
         get() = fir.initializer != null
 
@@ -61,6 +67,9 @@ class FirBackingFieldSymbol(callableId: CallableId) : FirVariableSymbol<FirBacki
     val isVar: Boolean
         get() = fir.isVar
 
+    val propertySymbol: FirPropertySymbol
+        get() = fir.propertySymbol
+
     val getterSymbol: FirPropertyAccessorSymbol?
         get() = fir.propertySymbol.fir.getter?.symbol
 }