[FIR IDE] Implement type annotations for fir symbols

idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt

@@ -19,7 +19,6 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.symbols.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtTypeArgumentList
@@ -67,7 +66,7 @@ private class TypeParameterLookupElementFactory {
 private class VariableLookupElementFactory {
     fun KtAnalysisSession.createLookup(symbol: KtVariableLikeSymbol): LookupElementBuilder {
         return LookupElementBuilder.create(UniqueLookupObject(), symbol.name.asString())
-            .withTypeText(symbol.type.render())
+            .withTypeText(symbol.annotatedType.type.render())
             .markIfSyntheticJavaProperty(symbol)
             .withInsertHandler(createInsertHandler(symbol))
     }
@@ -95,7 +94,7 @@ private class FunctionLookupElementFactory {
         return try {
             LookupElementBuilder.create(UniqueLookupObject(), symbol.name.asString())
                 .withTailText(getTailText(symbol), true)
-                .withTypeText(symbol.type.render())
+                .withTypeText(symbol.annotatedType.type.render())
                 .withInsertHandler(createInsertHandler(symbol))
         } catch (e: Throwable) {
             if (e is ControlFlowException) throw e
@@ -110,7 +109,7 @@ private class FunctionLookupElementFactory {
 
     private fun KtAnalysisSession.insertLambdaBraces(symbol: KtFunctionSymbol): Boolean {
         val singleParam = symbol.valueParameters.singleOrNull()
-        return singleParam != null && !singleParam.hasDefaultValue && singleParam.type.isBuiltInFunctionalType()
+        return singleParam != null && !singleParam.hasDefaultValue && singleParam.annotatedType.type.isBuiltInFunctionalType()
     }
 
     private fun KtAnalysisSession.createInsertHandler(symbol: KtFunctionSymbol): InsertHandler<LookupElement> {
@@ -232,7 +231,7 @@ private object ShortNamesRenderer {
         function.valueParameters.joinToString(", ", "(", ")") { renderFunctionParameter(it) }
 
     private fun KtAnalysisSession.renderFunctionParameter(param: KtFunctionParameterSymbol): String =
-        "${if (param.isVararg) "vararg " else ""}${param.name.asString()}: ${param.type.render()}"
+        "${if (param.isVararg) "vararg " else ""}${param.name.asString()}: ${param.annotatedType.type.render()}"
 }
 
 private fun Document.isTextAt(offset: Int, text: String) =

idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt

@@ -31,7 +31,7 @@ internal object ExpectedTypeWeigher {
     ) = when {
         expectedType == null -> MatchesExpectedType.NON_TYPABLE
         symbol !is KtTypedSymbol -> MatchesExpectedType.NON_TYPABLE
-        else -> MatchesExpectedType.matches(symbol.type isSubTypeOf expectedType)
+        else -> MatchesExpectedType.matches(symbol.annotatedType.type isSubTypeOf expectedType)
     }
 
 

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

@@ -8,11 +8,12 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithKind
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 
 abstract class KtAnonymousObjectSymbol : KtSymbolWithKind, KtAnnotatedSymbol, KtSymbolWithMembers {
-    abstract val superTypes: List<KtType>
+    abstract val superTypes: List<KtTypeAndAnnotations>
 
     abstract override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol>
 }

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

@@ -44,7 +44,7 @@ abstract class KtClassOrObjectSymbol : KtClassLikeSymbol(),
 
     abstract val companionObject: KtClassOrObjectSymbol?
 
-    abstract val superTypes: List<KtType>
+    abstract val superTypes: List<KtTypeAndAnnotations>
 
     abstract val primaryConstructor: KtConstructorSymbol?
 

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

@@ -15,7 +15,7 @@ interface KtNamedSymbol : KtSymbol {
 }
 
 interface KtTypedSymbol : KtSymbol {
-    val type: KtType
+    val annotatedType: KtTypeAndAnnotations
 }
 
 interface KtSymbolWithTypeParameters {

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.idea.asJava.FirLightPsiJavaCodeReferenceElementWithN
 import org.jetbrains.kotlin.idea.asJava.classes.createMethods
 import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtEnumEntrySymbol
-import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject
 
@@ -83,9 +82,9 @@ internal class FirLightClassForEnumEntry(
 
     private val _extendsList: PsiReferenceList? by lazyPub {
 
-        val mappedType = (enumEntrySymbol.type as? KtClassType)?.let {
+        val mappedType = enumEntrySymbol.annotatedType
-            it.mapSupertype(this@FirLightClassForEnumEntry)
+            .mapSupertype(this@FirLightClassForEnumEntry)
-        } ?: return@lazyPub null
+            ?: return@lazyPub null
 
         KotlinSuperTypeListBuilder(
             kotlinOrigin = enumClass.kotlinOrigin?.getSuperTypeList(),

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -268,7 +269,7 @@ internal fun FirLightClassBase.createField(
     )
 }
 
-internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
+internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtTypeAndAnnotations>): PsiReferenceList {
 
     val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST
 
@@ -296,8 +297,7 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su
 
     //TODO Add support for kotlin.collections.
     superTypes.asSequence()
-        .filterIsInstance<KtClassType>()
+        .filter { it.type.needToAddTypeIntoList() }
-        .filter { it.needToAddTypeIntoList() }
         .mapNotNull { it.mapSupertype(this, kotlinCollectionAsIs = true) }
         .forEach { listBuilder.addReference(it) }
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldEnumEntry.kt

@@ -65,7 +65,7 @@ internal class FirLightFieldForEnumEntry(
     override fun getName(): String = enumEntrySymbol.name.asString()
 
     private val _type: PsiType by lazyPub {
-        enumEntrySymbol.type.asPsiType(enumEntrySymbol, this@FirLightFieldForEnumEntry, FirResolvePhase.TYPES)
+        enumEntrySymbol.annotatedType.asPsiType(enumEntrySymbol, this@FirLightFieldForEnumEntry, FirResolvePhase.TYPES)
     }
 
     override fun getType(): PsiType = _type

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt

@@ -29,7 +29,7 @@ internal class FirLightFieldForPropertySymbol(
     override val kotlinOrigin: KtDeclaration? = propertySymbol.psi as? KtDeclaration
 
     private val _returnedType: PsiType by lazyPub {
-        propertySymbol.type.asPsiType(
+        propertySymbol.annotatedType.asPsiType(
             propertySymbol,
             this@FirLightFieldForPropertySymbol,
             FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE
@@ -83,7 +83,7 @@ internal class FirLightFieldForPropertySymbol(
         }
 
         val nullability = if (visibility != PsiModifier.PRIVATE && !(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit))
-            propertySymbol.type.getTypeNullability(propertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            propertySymbol.annotatedType.type.getTypeNullability(propertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
         else NullabilityType.Unknown
 
         val annotations = propertySymbol.computeAnnotations(

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt

@@ -16,14 +16,12 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMember
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.jvm.jvmTypeMapper
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.isPrimitiveType
 import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -38,7 +36,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
 import org.jetbrains.kotlin.idea.frontend.api.types.*
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
-import org.jetbrains.kotlin.load.kotlin.TypeMappingModeInternals
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 import java.text.StringCharacterIterator
@@ -52,17 +49,18 @@ private fun PsiElement.nonExistentType() = JavaPsiFacade.getElementFactory(proje
     .createTypeFromText("error.NonExistentClass", this)
 
 internal fun KtTypedSymbol.asPsiType(parent: PsiElement, phase: FirResolvePhase): PsiType =
-    type.asPsiType(this, parent, phase)
+    annotatedType.asPsiType(this, parent, phase)
 
-internal fun KtType.asPsiType(
+internal fun KtTypeAndAnnotations.asPsiType(
     context: KtSymbol,
     parent: PsiElement,
     phase: FirResolvePhase
 ): PsiType {
-    require(this is KtFirType)
+    val type = this.type
+    require(type is KtFirType)
     require(context is KtFirSymbol<*>)
     val session = context.firRef.withFir(phase) { it.session }
-    return coneType.asPsiType(session, context.firRef.resolveState, TypeMappingMode.DEFAULT, parent)
+    return type.coneType.asPsiType(session, context.firRef.resolveState, TypeMappingMode.DEFAULT, parent)
 }
 
 internal fun KtClassOrObjectSymbol.typeForClassSymbol(psiElement: PsiElement): PsiType {
@@ -153,12 +151,19 @@ private fun mapSupertype(
         psiContext
     ) as? PsiClassType
 
-internal fun KtClassType.mapSupertype(
+internal fun KtTypeAndAnnotations.mapSupertype(
     psiContext: PsiElement,
     kotlinCollectionAsIs: Boolean = false
+): PsiClassType? = type.mapSupertype(psiContext, kotlinCollectionAsIs, emptyList())
+
+internal fun KtType.mapSupertype(
+    psiContext: PsiElement,
+    kotlinCollectionAsIs: Boolean = false,
+    annotations: List<KtAnnotationCall>
 ): PsiClassType? {
+    if (this !is KtClassType) return null
     require(this is KtFirClassType)
-    val contextSymbol = this.classSymbol
+    val contextSymbol = classSymbol
     require(contextSymbol is KtFirSymbol<*>)
 
     val session = contextSymbol.firRef.withFir { it.session }
@@ -167,7 +172,7 @@ internal fun KtClassType.mapSupertype(
         psiContext,
         session,
         contextSymbol.firRef.resolveState,
-        this.coneType,
+        coneType,
         kotlinCollectionAsIs,
     )
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt

@@ -71,7 +71,7 @@ internal class FirLightAccessorMethodForSymbol(
                 !isPrivate &&
                 !(isParameter && (containingClass.isAnnotationType || containingClass.isEnum))
 
-        val nullabilityType = if (nullabilityApplicable) containingPropertySymbol.type
+        val nullabilityType = if (nullabilityApplicable) containingPropertySymbol.annotatedType.type
             .getTypeNullability(containingPropertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
         else NullabilityType.Unknown
 
@@ -144,7 +144,7 @@ internal class FirLightAccessorMethodForSymbol(
 
     private val _returnedType: PsiType? by lazyPub {
         if (!isGetter) return@lazyPub PsiType.VOID
-        return@lazyPub containingPropertySymbol.type.asPsiType(
+        return@lazyPub containingPropertySymbol.annotatedType.asPsiType(
             context = containingPropertySymbol,
             parent = this@FirLightAccessorMethodForSymbol,
             phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt

@@ -58,7 +58,7 @@ internal class FirLightSimpleMethodForSymbol(
     private fun computeAnnotations(isPrivate: Boolean): List<PsiAnnotation> {
         val nullability = if (isVoidReturnType || isPrivate)
             NullabilityType.Unknown
-        else functionSymbol.type.getTypeNullability(
+        else functionSymbol.annotatedType.type.getTypeNullability(
             context = functionSymbol,
             phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE
         )
@@ -122,7 +122,7 @@ internal class FirLightSimpleMethodForSymbol(
     override fun isConstructor(): Boolean = false
 
     private val isVoidReturnType: Boolean
-        get() = functionSymbol.type.run {
+        get() = functionSymbol.annotatedType.type.run {
             isUnit && nullabilityType != NullabilityType.Nullable
         }
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt

@@ -8,11 +8,8 @@ package org.jetbrains.kotlin.idea.asJava
 import com.intellij.psi.*
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.idea.frontend.api.symbols.*
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.idea.util.ifTrue
 import org.jetbrains.kotlin.psi.KtParameter
 
 internal abstract class FirLightParameterBaseForSymbol(
@@ -33,13 +30,17 @@ internal abstract class FirLightParameterBaseForSymbol(
         FirLightIdentifier(this, parameterSymbol)
     }
 
-    protected val nullabilityType: NullabilityType get() {
+    protected val nullabilityType: NullabilityType
-        val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } &&
+        get() {
-                !containingMethod.hasModifierProperty(PsiModifier.PRIVATE)
+            val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } &&
+                    !containingMethod.hasModifierProperty(PsiModifier.PRIVATE)
 
-        return if (nullabilityApplicable) parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES)
+            return if (nullabilityApplicable) parameterSymbol.annotatedType.type.getTypeNullability(
-        else NullabilityType.Unknown
+                parameterSymbol,
-    }
+                FirResolvePhase.TYPES
+            )
+            else NullabilityType.Unknown
+        }
 
     override fun getNameIdentifier(): PsiIdentifier = _identifier
 

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt

@@ -72,7 +72,7 @@ internal class FirLightParameterForReceiver private constructor(
     }
 
     private val _type: PsiType by lazyPub {
-        receiverTypeAndAnnotations.type.asPsiType(context, method, FirResolvePhase.TYPES)
+        receiverTypeAndAnnotations.asPsiType(context, method, FirResolvePhase.TYPES)
     }
 
     override fun getType(): PsiType = _type

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt

@@ -64,7 +64,13 @@ internal class FirLightTypeParameter(
         typeParameterSymbol.upperBounds
             .filterIsInstance<KtClassType>()
             .filter { it.classId != StandardClassIds.Any }
-            .mapNotNull { it.mapSupertype(this, kotlinCollectionAsIs = true) }
+            .mapNotNull {
+                it.mapSupertype(
+                    psiContext = this,
+                    kotlinCollectionAsIs = true,
+                    annotations = emptyList()
+                )
+            }
             .forEach { listBuilder.addReference(it) }
 
         listBuilder

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt

@@ -11,23 +11,16 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.argumentMapping
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
-import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
-import org.jetbrains.kotlin.idea.frontend.api.assertIsValid
-import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes
 import org.jetbrains.kotlin.idea.frontend.api.components.KtExpressionTypeProvider
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession
-import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypedSymbol
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.types.AbstractTypeChecker
-import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
 
 internal class KtFirExpressionTypeProvider(
     override val analysisSession: KtFirAnalysisSession,
@@ -66,7 +59,7 @@ internal class KtFirExpressionTypeProvider(
     private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? {
         val returnParent = expression.getReturnExpressionWithThisType() ?: return null
         val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null
-        return (targetSymbol as? KtTypedSymbol)?.type
+        return (targetSymbol as? KtTypedSymbol)?.annotatedType?.type
     }
 
     private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? =

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols
 
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -19,6 +20,8 @@ import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.*
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.FirRefWithValidityCheck
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.mapAnnotationParameters
@@ -27,37 +30,33 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtCallElement
 
-class KtFirAnnotationCall(
+internal class KtFirAnnotationCall(
-    containingDeclaration: FirDeclaration,
+    private val containingDeclaration: FirRefWithValidityCheck<FirDeclaration>,
-    annotationCall: FirAnnotationCall,
+    annotationCall: FirAnnotationCall
-    resolveState: FirModuleResolveState,
-    override val token: ValidityToken,
 ) : KtAnnotationCall() {
 
-    private val containingDeclarationRef = firRef(containingDeclaration, resolveState)
     private val annotationCallRef by weakRef(annotationCall)
 
-    override val psi: KtCallElement? by containingDeclarationRef.withFirAndCache { fir ->
+    override val token: ValidityToken get() = containingDeclaration.token
-        annotationCallRef.findPsi(fir.session) as? KtCallElement
+
+    override val psi: KtCallElement? by containingDeclaration.withFirAndCache { fir ->
+        fir.findPsi(fir.session) as? KtCallElement
     }
 
-    private fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType {
+    override val classId: ClassId? by containingDeclaration.withFirAndCache(FirResolvePhase.TYPES) { fir ->
-        val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this
-        val expandedType = firTypeAlias.fir.expandedTypeRef.coneType
-        return expandedType.fullyExpandedType(session) as? ConeClassLikeType
-            ?: return this
-    }
-
-    override val classId: ClassId? by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) {
         val declaredCone = annotationCallRef.annotationTypeRef.coneType as? ConeClassLikeType
-        declaredCone?.expandTypeAliasIfNeeded(it.session)?.classId
+        declaredCone?.expandTypeAliasIfNeeded(fir.session)?.classId
     }
 
     override val useSiteTarget: AnnotationUseSiteTarget? get() = annotationCallRef.useSiteTarget
 
-    override val arguments: List<KtNamedConstantValue> by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) {
+    override val arguments: List<KtNamedConstantValue> by containingDeclaration.withFirAndCache(FirResolvePhase.TYPES) { fir ->
-        mapAnnotationParameters(annotationCallRef, it.session).map { (name, expression) ->
+        mapAnnotationParameters(annotationCallRef, fir.session).map { (name, expression) ->
             KtNamedConstantValue(name, expression.convertConstantExpression())
         }
     }
 }
+
+internal fun FirRefWithValidityCheck<FirAnnotatedDeclaration>.toAnnotationsList() = withFir { fir ->
+    fir.annotations.map { KtFirAnnotationCall(this, it) }
+}

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

@@ -12,10 +12,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
 import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.*
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
 
@@ -28,7 +29,10 @@ internal class KtFirAnonymousFunctionSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { builder.buildKtType(it.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
+
     override val valueParameters: List<KtParameterSymbol> by firRef.withFirAndCache { fir ->
         fir.valueParameters.map { valueParameter ->
             check(valueParameter is FirValueParameterImpl)

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

@@ -7,20 +7,19 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.declarations.superConeTypes
 import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtAnonymousObjectSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 
 internal class KtFirAnonymousObjectSymbol(
     fir: FirAnonymousObject,
@@ -33,14 +32,12 @@ internal class KtFirAnonymousObjectSymbol(
     override val symbolKind: KtSymbolKind = KtSymbolKind.LOCAL
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
-    override val superTypes: List<KtType> by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir ->
+    override val superTypes: List<KtTypeAndAnnotations> by cached {
-        fir.superConeTypes.map {
+        firRef.superTypesAndAnnotationsList(builder)
-            builder.buildKtType(it)
-        }
     }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> =

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

@@ -13,18 +13,15 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirClassOrObjectInLibrarySymbol
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassKind
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolModality
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -46,8 +43,8 @@ internal class KtFirClassOrObjectSymbol(
 
     override val visibility: KtSymbolVisibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val isInner: Boolean get() = firRef.withFir(FirResolvePhase.STATUS) { it.isInner }
@@ -56,11 +53,10 @@ internal class KtFirClassOrObjectSymbol(
         fir.companionObject?.let { builder.buildClassSymbol(it) }
     }
 
-    override val superTypes: List<KtType> by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir ->
+    override val superTypes: List<KtTypeAndAnnotations> by cached {
-        fir.superConeTypes.map {
+        firRef.superTypesAndAnnotationsList(builder)
-            builder.buildKtType(it)
-        }
     }
+
     override val primaryConstructor: KtConstructorSymbol? by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { fir ->
         fir.getPrimaryConstructorIfAny()?.let { builder.buildConstructorSymbol(it) }
     }

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

@@ -16,16 +16,17 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirConstructorSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion
 import org.jetbrains.kotlin.name.ClassId
 
@@ -38,7 +39,10 @@ internal class KtFirConstructorSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { builder.buildKtType(it.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
+
     override val valueParameters: List<KtConstructorParameterSymbol> by firRef.withFirAndCache { fir ->
         fir.valueParameters.map { valueParameter ->
             check(valueParameter is FirValueParameterImpl)
@@ -48,8 +52,8 @@ internal class KtFirConstructorSymbol(
 
     override val visibility: KtSymbolVisibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val containingClassIdIfNonLocal: ClassId?

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

@@ -12,14 +12,15 @@ import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbolKind
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirConstructorValueParameterSymbol(
@@ -29,10 +30,12 @@ internal class KtFirConstructorValueParameterSymbol(
     private val builder: KtSymbolByFirBuilder
 ) : KtConstructorParameterSymbol(), KtFirSymbol<FirValueParameter> {
     override val firRef = firRef(fir, resolveState)
-    override val psi: PsiElement? by firRef.withFirAndCache {  fir -> fir.findPsi(fir.session) }
+    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { builder.buildKtType(it.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    }
     override val symbolKind: KtSymbolKind
         get() = firRef.withFir { fir ->
             when {
@@ -41,8 +44,8 @@ internal class KtFirConstructorValueParameterSymbol(
             }
         }
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val constructorParameterKind: KtConstructorParameterSymbolKind

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

@@ -15,11 +15,12 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirEnumEntrySymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtEnumEntrySymbol
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -34,7 +35,9 @@ internal class KtFirEnumEntrySymbol(
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
 
     override val containingEnumClassIdIfNonLocal: ClassId?
         get() = firRef.withFir { it.containingClass()?.classId?.takeUnless { it.isLocal } }

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

@@ -34,6 +34,6 @@ internal class KtFirFileSymbol(
     }
 
     override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        fir.annotations.map { KtFirAnnotationCall(firRef, it) }
     }
 }

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

@@ -15,13 +15,13 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberFunctionSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
@@ -34,7 +34,9 @@ internal class KtFirFunctionSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
     override val valueParameters: List<KtFirFunctionValueParameterSymbol> by firRef.withFirAndCache { fir ->
         fir.valueParameters.map { valueParameter ->
             check(valueParameter is FirValueParameterImpl)
@@ -47,17 +49,15 @@ internal class KtFirFunctionSymbol(
         }
     }
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend }
     override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
 
-    override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir ->
+    override val receiverType: KtTypeAndAnnotations? by cached {
-        fir.receiverTypeRef?.let { typeRef ->
+        firRef.receiverTypeAndAnnotations(builder)
-            KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder)
-        }
     }
 
     override val isOperator: Boolean get() = firRef.withFir { it.isOperator }

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

@@ -12,12 +12,13 @@ import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionParameterSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirFunctionValueParameterSymbol(
@@ -31,12 +32,14 @@ internal class KtFirFunctionValueParameterSymbol(
 
     override val name: Name get() = firRef.withFir { it.name }
     override val isVararg: Boolean get() = firRef.withFir { it.isVararg }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    }
 
     override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null }
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override fun createPointer(): KtSymbolPointer<KtFunctionParameterSymbol> {

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

@@ -13,10 +13,12 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtJavaFieldSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -30,7 +32,9 @@ internal class KtFirJavaFieldSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    }
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
 

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol
@@ -25,7 +26,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
@@ -45,12 +45,12 @@ internal class KtFirKotlinPropertySymbol(
 
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) }
 
-    override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir ->
+    override val annotatedType: KtTypeAndAnnotations by cached {
-        fir.receiverTypeRef?.let { typeRef ->
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-            KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder)
+    }
-        }
+    override val receiverType: KtTypeAndAnnotations? by cached {
+        firRef.receiverTypeAndAnnotations(builder)
     }
 
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
@@ -66,8 +66,8 @@ internal class KtFirKotlinPropertySymbol(
 
     override val visibility: KtSymbolVisibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val callableIdIfNonLocal: FqName?

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

@@ -11,12 +11,12 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtLocalVariableSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
@@ -38,7 +38,9 @@ internal class KtFirLocalVariableSymbol(
 
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
     override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL
 
     override fun createPointer(): KtSymbolPointer<KtLocalVariableSymbol> {

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

@@ -12,15 +12,12 @@ import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 
 internal class KtFirPropertyGetterSymbol(
     fir: FirPropertyAccessor,
@@ -48,11 +45,13 @@ internal class KtFirPropertyGetterSymbol(
             }
         }
 
-    override val type: KtType by firRef.withFirAndCache { builder.buildKtType(it.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    }
     override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() }
     override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() }
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol
@@ -42,8 +43,8 @@ internal class KtFirPropertySetterSymbol(
 
     override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() }
     override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() }
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
     override val parameter: KtSetterParameterSymbol by firRef.withFirAndCache { fir ->
         builder.buildFirSetterParameter(fir.valueParameters.single())

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

@@ -12,12 +12,13 @@ import org.jetbrains.kotlin.idea.fir.findPsi
 import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSetterParameterSymbol(
@@ -27,17 +28,18 @@ internal class KtFirSetterParameterSymbol(
     private val builder: KtSymbolByFirBuilder
 ) : KtSetterParameterSymbol(), KtFirSymbol<FirValueParameter> {
     override val firRef = firRef(fir, resolveState)
-    override val psi: PsiElement? by firRef.withFirAndCache {  fir -> fir.findPsi(fir.session) }
+    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
-
+        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    }
     override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null }
 
     override val isVararg: Boolean = false
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override fun createPointer(): KtSymbolPointer<KtSetterParameterSymbol> {

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

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol
@@ -25,7 +26,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
@@ -40,22 +40,20 @@ internal class KtFirSyntheticJavaPropertySymbol(
 
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
-    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) }
+    override val annotatedType: KtTypeAndAnnotations by cached {
-    override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir ->
+        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
-        fir.receiverTypeRef?.let { typeRef ->
+    }
-            KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder)
+    override val receiverType: KtTypeAndAnnotations? by cached {
-        }
+        firRef.receiverTypeAndAnnotations(builder)
     }
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
     override val initializer: KtConstantValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir -> fir.initializer?.convertConstantExpression() }
 
-
     override val modality: KtCommonSymbolModality get() = getModality()
-
     override val visibility: KtSymbolVisibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by firRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by cached {
-        fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) }
+        firRef.toAnnotationsList()
     }
 
     override val callableIdIfNonLocal: FqName?

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

@@ -5,36 +5,73 @@
 
 package org.jetbrains.kotlin.idea.frontend.api.fir.symbols
 
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
-import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.FirRefWithValidityCheck
+import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached
 import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 
-internal class KtFirTypeAndAnnotations(
+internal class KtFirTypeAndAnnotations<T : FirDeclaration>(
-    containingDeclaration: FirDeclaration,
+    private val containingDeclaration: FirRefWithValidityCheck<T>,
-    receiverTypeRef: FirTypeRef,
+    typeResolvePhase: FirResolvePhase,
-    resolveState: FirModuleResolveState,
+    private val builder: KtSymbolByFirBuilder,
-    override val token: ValidityToken,
+    private val typeRef: (T) -> FirTypeRef,
-    private val builder: KtSymbolByFirBuilder
 ) : KtTypeAndAnnotations() {
 
-    private val containingDeclarationRef = firRef(containingDeclaration, resolveState)
+    override val token: ValidityToken get() = containingDeclaration.token
-    private val receiverWeakTypeRef by weakRef(receiverTypeRef)
 
-    override val type: KtType by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) {
+    override val type: KtType by containingDeclaration.withFirAndCache(typeResolvePhase) { fir ->
-        builder.buildKtType(receiverWeakTypeRef)
+        builder.buildKtType(typeRef(fir))
     }
 
-    override val annotations: List<KtAnnotationCall> by containingDeclarationRef.withFirAndCache { fir ->
+    override val annotations: List<KtAnnotationCall> by containingDeclaration.withFirAndCache { fir ->
-        receiverWeakTypeRef.annotations.map {
+        typeRef(fir).annotations.map {
-            KtFirAnnotationCall(fir, it, resolveState, token)
+            KtFirAnnotationCall(containingDeclaration, it)
         }
     }
-}
+}
+
+internal class KtSimpleFirTypeAndAnnotations(
+    coneType: ConeKotlinType,
+    annotationsList: List<KtAnnotationCall>,
+    builder: KtSymbolByFirBuilder,
+    override val token: ValidityToken
+) : KtTypeAndAnnotations() {
+
+    private val coneTypeRef by weakRef(coneType)
+    private val annotationsListRef by weakRef(annotationsList)
+
+    override val type: KtType by cached {
+        builder.buildKtType(coneTypeRef)
+    }
+
+    override val annotations: List<KtAnnotationCall> get() = annotationsListRef
+}
+
+internal fun FirRefWithValidityCheck<FirClass<*>>.superTypesAndAnnotationsList(builder: KtSymbolByFirBuilder): List<KtTypeAndAnnotations> =
+    withFir(FirResolvePhase.SUPER_TYPES) { fir ->
+        fir.superTypeRefs.map { typeRef ->
+            val annotations = typeRef.annotations.map { annotation ->
+                KtFirAnnotationCall(this, annotation)
+            }
+            KtSimpleFirTypeAndAnnotations(typeRef.coneType, annotations, builder, token)
+        }
+    }
+
+internal fun FirRefWithValidityCheck<FirTypedDeclaration>.returnTypeAndAnnotations(
+    typeResolvePhase: FirResolvePhase,
+    builder: KtSymbolByFirBuilder
+) = KtFirTypeAndAnnotations(this, typeResolvePhase, builder) { it.returnTypeRef }
+
+internal fun FirRefWithValidityCheck<FirCallableDeclaration<*>>.receiverTypeAndAnnotations(builder: KtSymbolByFirBuilder) = withFir { fir ->
+    fir.receiverTypeRef?.let { _ ->
+        KtFirTypeAndAnnotations(this, FirResolvePhase.TYPES, builder) {
+            it.receiverTypeRef ?: error { "Receiver expected for callable declaration but it is null" }
+        }
+    }
+}

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

@@ -26,7 +26,7 @@ internal class KtFirTypeParameterSymbol(
     private val builder: KtSymbolByFirBuilder
 ) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameter> {
     override val firRef = firRef(fir, resolveState)
-    override val psi: PsiElement? by firRef.withFirAndCache { it.findPsi(fir.session) }
+    override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) }
 
     override val name: Name get() = firRef.withFir { it.name }
 

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

@@ -9,10 +9,16 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.java.JavaVisibilities
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.declarations.visibility
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
+import org.jetbrains.kotlin.fir.types.ConeClassLikeType
+import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolModality
 import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility
@@ -42,4 +48,12 @@ internal fun Visibility?.getSymbolVisibility(): KtSymbolVisibility = when (this)
 }
 
 internal fun <F : FirMemberDeclaration> KtFirSymbol<F>.getVisibility(): KtSymbolVisibility =
-    firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() }
+    firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() }
+
+
+internal fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType {
+    val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this
+    val expandedType = firTypeAlias.fir.expandedTypeRef.coneType
+    return expandedType.fullyExpandedType(session) as? ConeClassLikeType
+        ?: return this
+}

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
 import org.jetbrains.kotlin.idea.frontend.api.assertIsValid
 import java.lang.ref.WeakReference
 
-internal class FirRefWithValidityCheck<D : FirDeclaration>(fir: D, resolveState: FirModuleResolveState, val token: ValidityToken) {
+internal class FirRefWithValidityCheck<out D : FirDeclaration>(fir: D, resolveState: FirModuleResolveState, val token: ValidityToken) {
     private val firWeakRef = WeakReference(fir)
     private val resolveStateWeakRef = WeakReference(resolveState)
 

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

@@ -5,21 +5,18 @@
 package org.jetbrains.kotlin.idea.frontend.api.fir.utils
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.declarations.getPrimaryConstructorIfAny
-import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtConstantValue
-import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirAnnotationCall
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSimpleConstantValue
-import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.*
+import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtUnsupportedConstantValue
-import org.jetbrains.kotlin.psi.KtCallElement
-import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 
 internal fun mapAnnotationParameters(annotationCall: FirAnnotationCall, session: FirSession): Map<String, FirExpression> {
 

idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt

@@ -100,12 +100,12 @@ private fun KtCall.stringRepresentation(): String {
                 if (valueParameters.isNotEmpty()) append(", ")
             }
             valueParameters.joinTo(this) { parameter ->
-                "${parameter.name}: ${parameter.type.render()}"
+                "${parameter.name}: ${parameter.typeAndAnnotations.type.render()}"
             }
             append(")")
-            append(": ${type.render()}")
+            append(": ${typeAndAnnotations.type.render()}")
         }
-        is KtParameterSymbol -> "$name: ${type.render()}"
+        is KtParameterSymbol -> "$name: ${typeAndAnnotations.type.render()}"
         is KtSuccessCallTarget -> symbol.stringValue()
         is KtErrorCallTarget -> "ERR<${this.diagnostic.message}, [${candidates.joinToString { it.stringValue() }}]>"
         is Boolean -> toString()