Analysis API: get rid of KtTypeAndAnnotations & add annotations for every type

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/annotations/KtFe10AnnotationsList.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2021 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.descriptors.annotations
+
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
+
+internal class KtFe10AnnotationsList private constructor(
+    private val fe10Annotations: Annotations,
+    override val token: ValidityToken,
+) : KtAnnotationsList() {
+    override val annotations: List<KtAnnotationApplication>
+        get() = withValidityAssertion {
+            fe10Annotations.map { KtFe10DescAnnotationApplication(it, token) }
+        }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() {
+            withValidityAssertion {
+                val result = mutableListOf<ClassId>()
+                for (annotation in fe10Annotations) {
+                    val annotationClass = annotation.annotationClass ?: continue
+                    result += annotationClass.maybeLocalClassId
+                }
+                return result
+            }
+        }
+
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
+        return fe10Annotations.hasAnnotation(classId.asSingleFqName())
+    }
+
+    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> = withValidityAssertion {
+        fe10Annotations.mapNotNull { annotation ->
+            if (annotation.annotationClass?.maybeLocalClassId != classId) return@mapNotNull null
+            KtFe10DescAnnotationApplication(annotation, token)
+        }
+    }
+
+    companion object {
+        fun create(
+            fe10Annotations: Annotations,
+            token: ValidityToken,
+        ): KtAnnotationsList {
+            return if (!fe10Annotations.isEmpty()) {
+                KtFe10AnnotationsList(fe10Annotations, token)
+            } else {
+                KtEmptyAnnotationsList(token)
+            }
+        }
+    }
+}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/annotations/KtFe10DescAnnotationApplication.kt

@@ -3,12 +3,12 @@
  * 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.descriptors.symbols.descriptorBased
+package org.jetbrains.kotlin.analysis.api.descriptors.annotations
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.SourceElement
@@ -21,10 +21,10 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
-internal class KtFe10DescAnnotationCall(
+internal class KtFe10DescAnnotationApplication(
     private val descriptor: AnnotationDescriptor,
     override val token: ValidityToken
-) : KtAnnotationCall() {
+) : KtAnnotationApplication() {
     override val classId: ClassId?
         get() = withValidityAssertion { descriptor.annotationClass?.maybeLocalClassId }
 

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10AnnotatedSymbol.kt

@@ -5,36 +5,17 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.base
 
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescAnnotationCall
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
+import org.jetbrains.kotlin.analysis.api.descriptors.annotations.KtFe10AnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 
 internal interface KtFe10AnnotatedSymbol : KtAnnotatedSymbol, KtFe10Symbol {
     val annotationsObject: Annotations
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
         get() = withValidityAssertion {
-            annotationsObject.map { KtFe10DescAnnotationCall(it, token) }
+            KtFe10AnnotationsList.create(annotationsObject, token)
         }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() {
-            withValidityAssertion {
-                val result = mutableListOf<ClassId>()
-                for (annotation in annotationsObject) {
-                    val annotationClass = annotation.annotationClass ?: continue
-                    result += annotationClass.maybeLocalClassId
-                }
-                return result
-            }
-        }
-
-    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-        return annotationsObject.hasAnnotation(classId.asSingleFqName())
-    }
 }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt

@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktHasStableParameterNames
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
@@ -33,11 +33,11 @@ internal class KtFe10DescAnonymousFunctionSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt

@@ -7,12 +7,12 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 
@@ -20,8 +20,8 @@ internal class KtFe10DescAnonymousObjectSymbol(
     override val descriptor: ClassDescriptor,
     override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
-    override val superTypes: List<KtTypeAndAnnotations>
+    override val superTypes: List<KtType>
-        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisContext) } }
+        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtType(analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt

@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10Neve
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.name.ClassId
@@ -35,8 +35,8 @@ internal class KtFe10DescConstructorSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnType.toKtType(analysisContext) }
 
     override val typeParameters: List<KtTypeParameterSymbol>
         get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescDefaultPropertyGetterSymbol.kt

@@ -11,16 +11,18 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -53,8 +55,8 @@ class KtFe10DescDefaultPropertyGetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { propertyDescriptor.getterCallableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { propertyDescriptor.type.toKtType(analysisContext) }
 
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion { propertyDescriptor.getSymbolOrigin(analysisContext) }
@@ -62,8 +64,8 @@ class KtFe10DescDefaultPropertyGetterSymbol(
     override val psi: PsiElement?
         get() = withValidityAssertion { null }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val modality: Modality
         get() = withValidityAssertion { propertyDescriptor.ktModality }
@@ -71,17 +73,8 @@ class KtFe10DescDefaultPropertyGetterSymbol(
     override val visibility: Visibility
         get() = withValidityAssertion { propertyDescriptor.ktVisibility }
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
-        get() = withValidityAssertion { emptyList() }
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {
         withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescDefaultPropertySetterSymbol.kt

@@ -14,9 +14,11 @@ import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -54,8 +56,8 @@ class KtFe10DescDefaultPropertySetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { propertyDescriptor.setterCallableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtType(analysisContext) }
 
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion { propertyDescriptor.getSymbolOrigin(analysisContext) }
@@ -63,8 +65,8 @@ class KtFe10DescDefaultPropertySetterSymbol(
     override val psi: PsiElement?
         get() = withValidityAssertion { null }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val modality: Modality
         get() = withValidityAssertion { propertyDescriptor.ktModality }
@@ -72,17 +74,8 @@ class KtFe10DescDefaultPropertySetterSymbol(
     override val visibility: Visibility
         get() = withValidityAssertion { propertyDescriptor.ktVisibility }
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
-        get() = withValidityAssertion { emptyList() }
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
 
     override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
         withValidityAssertion {
@@ -103,8 +96,8 @@ class KtFe10DescDefaultPropertySetterSymbol(
         override val name: Name
             get() = withValidityAssertion { Name.identifier("value") }
 
-        override val annotatedType: KtTypeAndAnnotations
+        override val type: KtType
-            get() = withValidityAssertion { propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+            get() = withValidityAssertion { propertyDescriptor.type.toKtType(analysisContext) }
 
         override val origin: KtSymbolOrigin
             get() = withValidityAssertion { propertyDescriptor.getSymbolOrigin(analysisContext) }
@@ -112,17 +105,9 @@ class KtFe10DescDefaultPropertySetterSymbol(
         override val psi: PsiElement?
             get() = withValidityAssertion { null }
 
-        override val annotations: List<KtAnnotationCall>
+        override val annotationsList: KtAnnotationsList
-            get() = withValidityAssertion { emptyList() }
+            get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
 
-        override fun containsAnnotation(classId: ClassId): Boolean {
-            withValidityAssertion {
-                return false
-            }
-        }
-
-        override val annotationClassIds: Collection<ClassId>
-            get() = withValidityAssertion { emptyList() }
 
         override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
             withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt

@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescEnumEntrySymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.name.CallableId
@@ -41,8 +41,8 @@ internal class KtFe10DescEnumEntrySymbol(
             )
         }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { enumDescriptor.defaultType.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { enumDescriptor.defaultType.toKtType(analysisContext) }
 
     override val name: Name
         get() = withValidityAssertion { descriptor.name }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt

@@ -13,9 +13,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
@@ -65,11 +65,11 @@ internal class KtFe10DescFunctionSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { descriptor.callableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val isExtension: Boolean
         get() = withValidityAssertion { descriptor.isExtension }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.callableIdIfNotLocal
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtJavaFieldSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
 import org.jetbrains.kotlin.name.CallableId
@@ -36,8 +36,8 @@ internal class KtFe10DescJavaFieldSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { descriptor.callableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnType.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt

@@ -14,9 +14,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
@@ -85,11 +85,11 @@ internal class KtFe10DescKotlinPropertySymbol(
             return KtFe10DescPropertySetterSymbol(setter, analysisContext)
         }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val typeParameters: List<KtTypeParameterSymbol>
         get() = withValidityAssertion { descriptor.typeParameters.map { it.toKtTypeParameter(analysisContext) } }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt

@@ -7,13 +7,13 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
 import org.jetbrains.kotlin.name.Name
@@ -28,8 +28,8 @@ internal class KtFe10DescLocalVariableSymbol(
     override val isVal: Boolean
         get() = withValidityAssertion { !descriptor.isVar }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }
 
     override val symbolKind: KtSymbolKind
         get() = withValidityAssertion { KtSymbolKind.LOCAL }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt

@@ -13,9 +13,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
@@ -71,9 +71,9 @@ internal class KtFe10DescNamedClassOrObjectSymbol(
             }
         }
 
-    override val superTypes: List<KtTypeAndAnnotations>
+    override val superTypes: List<KtType>
         get() = withValidityAssertion {
-            descriptor.getSupertypesWithAny().map { it.toKtTypeAndAnnotations(analysisContext) }
+            descriptor.getSupertypesWithAny().map { it.toKtType(analysisContext) }
         }
 
     override val classIdIfNonLocal: ClassId?

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
 import org.jetbrains.kotlin.descriptors.hasBody
@@ -44,11 +44,11 @@ internal class KtFe10DescPropertyGetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { descriptor.correspondingProperty.getterCallableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
 import org.jetbrains.kotlin.descriptors.hasBody
@@ -22,8 +22,8 @@ internal class KtFe10DescPropertySetterSymbol(
     override val descriptor: PropertySetterDescriptor,
     override val analysisContext: Fe10AnalysisContext
 ) : KtPropertySetterSymbol(), KtFe10DescMemberSymbol<PropertySetterDescriptor> {
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtType(analysisContext) }
 
     override val isDefault: Boolean
         get() = withValidityAssertion { descriptor.isDefault }
@@ -49,8 +49,8 @@ internal class KtFe10DescPropertySetterSymbol(
     override val parameter: KtValueParameterSymbol
         get() = withValidityAssertion { KtFe10DescValueParameterSymbol(descriptor.valueParameters.single(), analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
         withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt

@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10Neve
 import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
@@ -41,11 +41,11 @@ internal class KtFe10DescSamConstructorSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { expandedDescriptor.callableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val isExtension: Boolean
         get() = withValidityAssertion { descriptor.isExtension }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt

@@ -7,16 +7,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescSyntheticFieldSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtVariableLikeSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
@@ -35,8 +35,8 @@ internal class KtFe10DescSyntheticFieldSymbol(
             KtFe10DescKotlinPropertySymbol(kotlinProperty, analysisContext)
         }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtVariableLikeSymbol> = withValidityAssertion {
         val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.name.CallableId
@@ -77,11 +77,11 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { descriptor.callableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
 
     override val typeParameters: List<KtTypeParameterSymbol>

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor
@@ -77,11 +77,11 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { descriptor.callableIdIfNotLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val typeParameters: List<KtTypeParameterSymbol>
         get() = withValidityAssertion { descriptor.typeParameters.map { it.toKtTypeParameter(analysisContext) } }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.name.Name
@@ -39,9 +39,9 @@ internal class KtFe10DescValueParameterSymbol(
     override val isVararg: Boolean
         get() = withValidityAssertion { descriptor.isVararg }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            return (descriptor.varargElementType ?: descriptor.type).toKtTypeAndAnnotations(analysisContext)
+            return (descriptor.varargElementType ?: descriptor.type).toKtType(analysisContext)
         }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt

@@ -8,13 +8,13 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.ba
 import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.types.*
-import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10TypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10Renderer
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
@@ -184,10 +184,6 @@ internal fun KotlinType.toKtType(analysisContext: Fe10AnalysisContext): KtType {
     }
 }
 
-internal fun KotlinType.toKtTypeAndAnnotations(analysisContext: Fe10AnalysisContext): KtTypeAndAnnotations {
-    return KtFe10TypeAndAnnotations(toKtType(analysisContext), this, analysisContext.token)
-}
-
 internal fun TypeProjection.toKtTypeArgument(analysisContext: Fe10AnalysisContext): KtTypeArgument {
     return if (isStarProjection) {
         KtStarProjectionTypeArgument(analysisContext.token)

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt

@@ -8,16 +8,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -39,20 +39,20 @@ internal class KtFe10PsiAnonymousFunctionSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
         }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             if (psi.isExtensionDeclaration()) {
                 return null
             }
 
-            val descriptor = this.descriptor ?: return createErrorTypeAndAnnotations()
+            val descriptor = this.descriptor ?: return createErrorType()
             val extensionReceiverParameter = descriptor.extensionReceiverParameter ?: return null
-            return extensionReceiverParameter.type.toKtTypeAndAnnotations(analysisContext)
+            return extensionReceiverParameter.type.toKtType(analysisContext)
         }
 
     override val isExtension: Boolean

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt

@@ -8,14 +8,14 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousObjectSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.psi.KtObjectDeclaration
@@ -30,9 +30,9 @@ internal class KtFe10PsiAnonymousObjectSymbol(
         bindingContext[BindingContext.CLASS, psi]
     }
 
-    override val superTypes: List<KtTypeAndAnnotations>
+    override val superTypes: List<KtType>
         get() = withValidityAssertion {
-            descriptor?.typeConstructor?.supertypes?.map { it.toKtTypeAndAnnotations(analysisContext) } ?: emptyList()
+            descriptor?.typeConstructor?.supertypes?.map { it.toKtType(analysisContext) } ?: emptyList()
         }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt

@@ -8,18 +8,18 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -50,9 +50,9 @@ internal class KtFe10PsiConstructorSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
         }
 
     override val visibility: Visibility

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultPropertyGetterSymbol.kt

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
@@ -21,9 +21,11 @@ import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -72,13 +74,13 @@ class KtFe10PsiDefaultPropertyGetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { null }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             return if (propertyPsi.isExtensionDeclaration()) {
-                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+                descriptor?.extensionReceiverParameter?.type?.toKtType(analysisContext) ?: createErrorType()
             } else {
                 null
             }
@@ -90,17 +92,8 @@ class KtFe10PsiDefaultPropertyGetterSymbol(
     override val visibility: Visibility
         get() = withValidityAssertion { propertyPsi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
-        get() = withValidityAssertion { emptyList() }
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
         return KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultPropertySetterSymbol.kt

@@ -6,24 +6,25 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -77,15 +78,15 @@ class KtFe10PsiDefaultPropertySetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { null }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            return analysisContext.builtIns.unitType.toKtTypeAndAnnotations(analysisContext)
+            return analysisContext.builtIns.unitType.toKtType(analysisContext)
         }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             return if (propertyPsi.isExtensionDeclaration()) {
-                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+                descriptor?.extensionReceiverParameter?.type?.toKtType(analysisContext) ?: createErrorType()
             } else {
                 null
             }
@@ -97,17 +98,8 @@ class KtFe10PsiDefaultPropertySetterSymbol(
     override val visibility: Visibility
         get() = withValidityAssertion { propertyPsi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
-        get() = withValidityAssertion { emptyList() }
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
 
     override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> = withValidityAssertion {
         return KtFe10NeverRestoringSymbolPointer()
@@ -127,8 +119,8 @@ class KtFe10PsiDefaultPropertySetterSymbol(
         override val name: Name
             get() = withValidityAssertion { Name.identifier("value") }
 
-        override val annotatedType: KtTypeAndAnnotations
+        override val type: KtType
-            get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+            get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
         override val origin: KtSymbolOrigin
             get() = withValidityAssertion { propertyPsi.ktSymbolOrigin }
@@ -136,15 +128,8 @@ class KtFe10PsiDefaultPropertySetterSymbol(
         override val psi: PsiElement?
             get() = withValidityAssertion { null }
 
-        override val annotations: List<KtAnnotationCall>
+        override val annotationsList: KtAnnotationsList
-            get() = withValidityAssertion { emptyList() }
+            get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-        override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-            return false
-        }
-
-        override val annotationClassIds: Collection<ClassId>
-            get() = withValidityAssertion { emptyList() }
 
         override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
             return KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt

@@ -10,15 +10,17 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.name.ClassId
@@ -44,8 +46,8 @@ internal class KtFe10PsiDefaultSetterParameterSymbol(
     override val isVararg: Boolean
         get() = withValidityAssertion { false }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
     override val psi: PsiElement?
         get() = withValidityAssertion { null }
@@ -53,15 +55,8 @@ internal class KtFe10PsiDefaultSetterParameterSymbol(
     override val name: Name
         get() = withValidityAssertion { descriptor?.name ?: Name.identifier("value") }
 
-    override val annotations: List<KtAnnotationCall>
+    override val annotationsList: KtAnnotationsList
-        get() = withValidityAssertion { emptyList() }
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }
-
-    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-        return false
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
         return KtFe10NeverRestoringSymbolPointer()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt

@@ -8,16 +8,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.callableIdIfNonLocal
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
@@ -46,13 +46,13 @@ internal class KtFe10PsiEnumEntrySymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { psi.callableIdIfNonLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
             val containingDescriptor = descriptor?.containingDeclaration
             if (containingDescriptor is ClassDescriptor && containingDescriptor.kind == ClassKind.ENUM_CLASS) {
-                return containingDescriptor.defaultType.toKtTypeAndAnnotations(analysisContext)
+                return containingDescriptor.defaultType.toKtType(analysisContext)
             } else {
-                createErrorTypeAndAnnotations()
+                createErrorType()
             }
         }
 

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
@@ -71,18 +71,18 @@ internal class KtFe10PsiFunctionSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { psi.callableIdIfNonLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType() }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             if (!psi.isExtensionDeclaration()) {
                 return null
             }
 
-            val descriptor = this.descriptor ?: return createErrorTypeAndAnnotations()
+            val descriptor = this.descriptor ?: return createErrorType()
             val extensionReceiverParameter = descriptor.extensionReceiverParameter ?: return null
-            return extensionReceiverParameter.type.toKtTypeAndAnnotations(analysisContext)
+            return extensionReceiverParameter.type.toKtType(analysisContext)
         }
 
     override val isExtension: Boolean

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.Analysis
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtUnsupportedConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
@@ -119,13 +119,13 @@ internal class KtFe10PsiKotlinPropertySymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { psi.callableIdIfNonLocal }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             return if (psi.isExtensionDeclaration()) {
-                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+                descriptor?.extensionReceiverParameter?.type?.toKtType(analysisContext) ?: createErrorType()
             } else {
                 null
             }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt

@@ -7,16 +7,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.psi.KtFunctionLiteral
@@ -45,16 +45,16 @@ internal class KtFe10PsiLiteralAnonymousFunctionSymbol(
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
         }
 
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
-            val descriptor = this.descriptor ?: return createErrorTypeAndAnnotations()
+            val descriptor = this.descriptor ?: return createErrorType()
             val extensionReceiverParameter = descriptor.extensionReceiverParameter ?: return null
-            extensionReceiverParameter.type.toKtTypeAndAnnotations(analysisContext)
+            extensionReceiverParameter.type.toKtType(analysisContext)
         }
 
     override val isExtension: Boolean

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt

@@ -8,16 +8,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.name.Name
@@ -36,8 +36,8 @@ internal class KtFe10PsiLocalVariableSymbol(
     override val name: Name
         get() = withValidityAssertion { psi.nameAsSafeName }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
     override val isVal: Boolean
         get() = withValidityAssertion { !psi.isVar }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLoopParameterLocalVariableSymbol.kt

@@ -7,16 +7,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtLocalVariableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.name.Name
@@ -35,8 +35,8 @@ internal class KtFe10PsiLoopParameterLocalVariableSymbol(
     override val name: Name
         get() = withValidityAssertion { psi.nameAsSafeName }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }
 
     override val isVal: Boolean
         get() = withValidityAssertion { !psi.isMutable }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSupertypesWithAny
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
@@ -22,9 +22,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
@@ -88,9 +88,9 @@ internal class KtFe10PsiNamedClassOrObjectSymbol(
             }
         }
 
-    override val superTypes: List<KtTypeAndAnnotations>
+    override val superTypes: List<KtType>
         get() = withValidityAssertion {
-            descriptor?.getSupertypesWithAny()?.map { it.toKtTypeAndAnnotations(analysisContext) } ?: emptyList()
+            descriptor?.getSupertypesWithAny()?.map { it.toKtType(analysisContext) } ?: emptyList()
         }
 
     override val classIdIfNonLocal: ClassId?

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt

@@ -9,18 +9,18 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
@@ -67,16 +67,16 @@ internal class KtFe10PsiPropertyGetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { null }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
         }
-    override val receiverType: KtTypeAndAnnotations?
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext)
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext)
-                !psi.property.isTopLevel -> createErrorTypeAndAnnotations()
+                !psi.property.isTopLevel -> createErrorType()
                 else -> null
             }
         }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt

@@ -9,18 +9,18 @@ import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
@@ -68,16 +68,17 @@ internal class KtFe10PsiPropertySetterSymbol(
     override val callableIdIfNonLocal: CallableId?
         get() = withValidityAssertion { null }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtType(analysisContext) ?: createErrorType()
         }
-    override val receiverType: KtTypeAndAnnotations?
+
+    override val receiverType: KtType?
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext)
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext)
-                psi.property.isExtensionDeclaration() -> createErrorTypeAndAnnotations()
+                psi.property.isExtensionDeclaration() -> createErrorType()
                 else -> null
             }
         }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt

@@ -8,15 +8,15 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.createErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
@@ -39,10 +39,10 @@ internal class KtFe10PsiValueParameterSymbol(
     override val isVararg: Boolean
         get() = withValidityAssertion { psi.isVarArg }
 
-    override val annotatedType: KtTypeAndAnnotations
+    override val type: KtType
         get() = withValidityAssertion {
             val type = (descriptor as? ValueParameterDescriptor)?.varargElementType ?: descriptor?.type
-            return type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
+            return type?.toKtType(analysisContext) ?: createErrorType()
         }
 
     override val name: Name

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt

@@ -9,9 +9,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10ClassErrorType
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
@@ -148,19 +147,6 @@ internal fun PsiElement.getResolutionScope(bindingContext: BindingContext): Lexi
     return null
 }
 
-internal fun KtFe10Symbol.createErrorTypeAndAnnotations(): KtTypeAndAnnotations {
-    val errorType = createErrorType()
-
-    return object : KtTypeAndAnnotations() {
-        override val type: KtType
-            get() = withValidityAssertion { errorType }
-        override val annotations: List<KtAnnotationCall>
-            get() = withValidityAssertion { emptyList() }
-        override val token: ValidityToken
-            get() = this@createErrorTypeAndAnnotations.token
-
-    }
-}
 
 internal fun KtFe10Symbol.createErrorType(): KtType {
     val type = ErrorUtils.createErrorType("Type is unavailable for declaration $psi") as ErrorType

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt

@@ -6,18 +6,27 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.types.base
 
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotated
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
+import org.jetbrains.kotlin.analysis.api.descriptors.annotations.KtFe10AnnotationsList
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.UnwrappedType
 
-interface KtFe10Type : ValidityTokenOwner {
+interface KtFe10Type : ValidityTokenOwner, KtAnnotated {
     val type: UnwrappedType
 
     val analysisContext: Fe10AnalysisContext
 
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion {
+            KtFe10AnnotationsList.create(type.annotations, token)
+        }
+
     override val token: ValidityToken
         get() = analysisContext.token
 }

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10TypeAndAnnotations.kt

@@ -1,25 +0,0 @@
-/*
- * Copyright 2010-2021 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.descriptors.types.base
-
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
-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.types.KotlinType
-
-internal class KtFe10TypeAndAnnotations(
-    override val type: KtType,
-    private val originalType: KotlinType,
-    override val token: ValidityToken
-) : KtTypeAndAnnotations() {
-    override val annotations: List<KtAnnotationCall>
-        get() = withValidityAssertion {
-            originalType.annotations.map { KtFe10DescAnnotationCall(it, token) }
-        }
-}

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.utils
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId

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

@@ -365,7 +365,7 @@ internal class KtSymbolByFirBuilder private constructor(
                     is ConeFlexibleType -> KtFirFlexibleType(coneType, token, this@KtSymbolByFirBuilder)
                     is ConeIntersectionType -> KtFirIntersectionType(coneType, token, this@KtSymbolByFirBuilder)
                     is ConeDefinitelyNotNullType -> KtFirDefinitelyNotNullType(coneType, token, this@KtSymbolByFirBuilder)
-                    is ConeCapturedType -> KtFirCapturedType(coneType, token)
+                    is ConeCapturedType -> KtFirCapturedType(coneType, token, this@KtSymbolByFirBuilder)
                     is ConeIntegerLiteralType -> KtFirIntegerLiteralType(coneType, token, this@KtSymbolByFirBuilder)
                     else -> throwUnexpectedElementError(coneType)
                 }

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

@@ -3,56 +3,55 @@
  * 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.symbols.annotations
+package org.jetbrains.kotlin.analysis.api.fir.annotations
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
+import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
+import org.jetbrains.kotlin.analysis.api.fir.utils.cached
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.findPsi
+import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
-import org.jetbrains.kotlin.analysis.api.fir.utils.*
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedConstantValue
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtCallElement
 
-internal class KtFirAnnotationCall(
+internal class KtFirAnnotationApplicationForDeclaration(
     private val containingDeclaration: FirRefWithValidityCheck<FirDeclaration>,
-    annotation: FirAnnotation,
+    private val useSiteSession: FirSession,
-) : KtAnnotationCall() {
+    private val annotation: FirAnnotation,
+    override val token: ValidityToken,
+) : KtAnnotationApplication() {
 
-    private val annotationCallRef by weakRef(annotation)
+    override val psi: KtCallElement? by cached { annotation.psi as? KtCallElement }
-
-    override val token: ValidityToken get() = containingDeclaration.token
-
-    override val psi: KtCallElement? by containingDeclaration.withFirAndCache { fir ->
-        annotationCallRef.findPsi(fir.moduleData.session) as? KtCallElement
-    }
 
     override val classId: ClassId? by cached {
-        containingDeclaration.withFirByType(ResolveType.AnnotationType) { fir ->
+        containingDeclaration.withFirByType(ResolveType.AnnotationType) {
-            annotationCallRef.getClassId(fir.moduleData.session)
+            annotation.fullyExpandedClassId(useSiteSession)
         }
     }
 
-    override val useSiteTarget: AnnotationUseSiteTarget? get() = annotationCallRef.useSiteTarget
+    override val useSiteTarget: AnnotationUseSiteTarget? get() = withValidityAssertion { annotation.useSiteTarget }
 
-    override val arguments: List<KtNamedConstantValue> by containingDeclaration.withFirAndCache(ResolveType.AnnotationsArguments) { fir ->
+    override val arguments: List<KtNamedConstantValue> by containingDeclaration.withFirAndCache(ResolveType.AnnotationsArguments) {
         KtFirConstantValueConverter.toNamedConstantValue(
-            mapAnnotationParameters(annotationCallRef, fir.moduleData.session),
+            mapAnnotationParameters(annotation, useSiteSession),
-            fir.moduleData.session,
+            useSiteSession,
         )
     }
 
     override fun equals(other: Any?): Boolean {
-        if (other !is KtFirAnnotationCall) return false
+        if (other !is KtFirAnnotationApplicationForDeclaration) return false
         if (this.token != other.token) return false
-        return annotationCallRef == other.annotationCallRef
+        return annotation == other.annotation
     }
 
     override fun hashCode(): Int {
-        return token.hashCode() * 31 + annotationCallRef.hashCode()
+        return token.hashCode() * 31 + annotation.hashCode()
     }
-}
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
+import org.jetbrains.kotlin.analysis.api.fir.utils.cached
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.psi
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.psi.KtCallElement
+
+internal class KtFirAnnotationApplicationImpl(
+    private val annotation: FirAnnotation,
+    private val useSiteSession: FirSession,
+    override val token: ValidityToken,
+) : KtAnnotationApplication() {
+
+    override val psi: KtCallElement? by cached { annotation.psi as? KtCallElement }
+
+    override val classId: ClassId?
+        get() = withValidityAssertion {
+            annotation.fullyExpandedClassId(useSiteSession)
+        }
+
+    override val useSiteTarget: AnnotationUseSiteTarget? get() = annotation.useSiteTarget
+
+    override val arguments: List<KtNamedConstantValue> by cached {
+        KtFirConstantValueConverter.toNamedConstantValue(
+            mapAnnotationParameters(annotation, useSiteSession),
+            useSiteSession,
+        )
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (other !is KtFirAnnotationApplicationImpl) return false
+        return annotation == other.annotation
+    }
+
+    override fun hashCode(): Int {
+        return annotation.hashCode()
+    }
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+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.fir.FirSession
+import org.jetbrains.kotlin.name.ClassId
+
+internal class KtFirAnnotationListForDeclaration private constructor(
+    val firRef: FirRefWithValidityCheck<*>,
+    private val useSiteSession: FirSession,
+    override val token: ValidityToken,
+) : KtAnnotationsList() {
+    override val annotations: List<KtAnnotationApplication>
+        get() = firRef.withFir { fir ->
+            fir.annotations.map { annotation ->
+                KtFirAnnotationApplicationForDeclaration(firRef, useSiteSession, annotation, token)
+            }
+        }
+
+
+    override fun containsAnnotation(classId: ClassId): Boolean {
+        return firRef.withFirByType(ResolveType.AnnotationType) { fir ->
+            fir.annotations.any { it.fullyExpandedClassId(useSiteSession) == classId }
+        }
+    }
+
+    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> = firRef.withFir { fir ->
+        fir.annotations.mapNotNull { annotation ->
+            if (annotation.fullyExpandedClassId(useSiteSession) != classId) return@mapNotNull null
+            KtFirAnnotationApplicationForDeclaration(firRef, useSiteSession, annotation, token)
+        }
+    }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() = firRef.withFirByType(ResolveType.AnnotationType) { fir ->
+            fir.annotations.mapNotNull { it.fullyExpandedClassId(useSiteSession) }
+        }
+
+    companion object {
+        fun create(
+            firRef: FirRefWithValidityCheck<*>,
+            useSiteSession: FirSession,
+            token: ValidityToken,
+        ): KtAnnotationsList {
+            return if (firRef.withFir { it.annotations.isEmpty() }) {
+                KtEmptyAnnotationsList(token)
+            } else {
+                KtFirAnnotationListForDeclaration(firRef, useSiteSession, token)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.impl.base.annotations.KtEmptyAnnotationsList
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.customAnnotations
+import org.jetbrains.kotlin.name.ClassId
+
+internal class KtFirAnnotationListForType private constructor(
+    val coneType: ConeKotlinType,
+    private val useSiteSession: FirSession,
+    override val token: ValidityToken,
+) : KtAnnotationsList() {
+    override val annotations: List<KtAnnotationApplication>
+        get() = withValidityAssertion { coneType.customAnnotations.map { KtFirAnnotationApplicationImpl(it, useSiteSession, token) } }
+
+
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
+        coneType.customAnnotations.any { it.fullyExpandedClassId(useSiteSession) == classId }
+    }
+
+    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> = withValidityAssertion {
+        coneType.customAnnotations.mapNotNull { annotation ->
+            if (annotation.fullyExpandedClassId(useSiteSession) != classId) return@mapNotNull null
+            KtFirAnnotationApplicationImpl(annotation, useSiteSession, token)
+        }
+    }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() = withValidityAssertion { coneType.customAnnotations.mapNotNull { it.fullyExpandedClassId(useSiteSession) } }
+
+
+    companion object {
+        fun create(
+            coneType: ConeKotlinType,
+            useSiteSession: FirSession,
+            token: ValidityToken,
+        ): KtAnnotationsList {
+            return if (coneType.customAnnotations.isEmpty()) {
+                KtEmptyAnnotationsList(token)
+            } else {
+                KtFirAnnotationListForType(coneType, useSiteSession, token)
+            }
+        }
+    }
+}
+

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

@@ -3,12 +3,9 @@
  * 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.symbols.annotations
+package org.jetbrains.kotlin.analysis.api.fir.annotations
 
-import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
-import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny
 import org.jetbrains.kotlin.fir.declarations.resolved
@@ -20,23 +17,6 @@ import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.name.ClassId
 
-internal fun FirAnnotation.getClassId(session: FirSession): ClassId? =
-    coneClassLikeType?.fullyExpandedType(session)?.classId
-
-internal fun FirRefWithValidityCheck<FirDeclaration>.toAnnotationsList() = withFir { fir ->
-    fir.annotations.map { KtFirAnnotationCall(this, it) }
-}
-
-internal fun FirRefWithValidityCheck<FirDeclaration>.containsAnnotation(classId: ClassId): Boolean =
-    withFirByType(ResolveType.AnnotationType) { fir ->
-        fir.annotations.any { it.getClassId(fir.moduleData.session) == classId }
-    }
-
-internal fun FirRefWithValidityCheck<FirDeclaration>.getAnnotationClassIds(): Collection<ClassId> =
-    withFirByType(ResolveType.AnnotationType) { fir ->
-        fir.annotations.mapNotNull { it.getClassId(fir.moduleData.session) }
-    }
-
 internal fun mapAnnotationParameters(annotation: FirAnnotation, session: FirSession): Map<String, FirExpression> {
     if (annotation.resolved) return annotation.argumentMapping.mapping.mapKeys { (name, _) -> name.identifier }
     if (annotation !is FirAnnotationCall) return emptyMap()
@@ -69,3 +49,6 @@ internal fun mapAnnotationParameters(annotation: FirAnnotation, session: FirSess
 
     return resultMap
 }
+
+internal fun FirAnnotation.fullyExpandedClassId(useSiteSession: FirSession): ClassId? =
+    coneClassLikeType?.fullyExpandedType(useSiteSession)?.classId

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

@@ -149,7 +149,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.annotatedType.type
+        return targetSymbol.type
     }
 
     private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? =

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/KtFirConstantValueConverter.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.evaluate
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
@@ -131,7 +132,7 @@ internal object KtFirConstantValueConverter {
                     else -> null
                 }
             }
-            else -> KtUnsupportedConstantValue
+            else -> null
-        }
+        } ?: FirCompileTimeConstantEvaluator.evaluate(this)?.convertConstantExpression()
     }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.renderer
 
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.mapAnnotationParameters
+import org.jetbrains.kotlin.analysis.api.fir.annotations.mapAnnotationParameters
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId

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

@@ -14,13 +14,12 @@ 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.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.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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
 
 internal class KtFirAnonymousFunctionSymbol(
     fir: FirAnonymousFunction,
@@ -31,8 +30,8 @@ internal class KtFirAnonymousFunctionSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
@@ -44,8 +43,8 @@ internal class KtFirAnonymousFunctionSymbol(
     override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
 
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> {

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

@@ -10,20 +10,15 @@ 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.symbols.annotations.containsAnnotation
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.KtAnonymousObjectSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.name.ClassId
+import org.jetbrains.kotlin.analysis.api.types.KtType
 
 internal class KtFirAnonymousObjectSymbol(
     fir: FirAnonymousObject,
@@ -34,13 +29,10 @@ internal class KtFirAnonymousObjectSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
-    override val superTypes: List<KtTypeAndAnnotations> by cached {
+
-        firRef.superTypesAndAnnotationsList(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/KtFirBackingFieldSymbol.kt

@@ -12,12 +12,11 @@ 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.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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
 
 internal class KtFirBackingFieldSymbol(
     propertyFir: FirProperty,
@@ -27,8 +26,8 @@ internal class KtFirBackingFieldSymbol(
 ) : KtBackingFieldSymbol() {
     private val propertyFirRef = firRef(propertyFir, resolveState)
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        propertyFirRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+        propertyFirRef.returnType(FirResolvePhase.TYPES, builder)
     }
 
     override val owningProperty: KtKotlinPropertySymbol by propertyFirRef.withFirAndCache { fir ->

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

@@ -7,23 +7,20 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 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.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.api.withValidityAssertion
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.descriptors.Visibility
@@ -42,8 +39,8 @@ internal class KtFirConstructorSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
@@ -56,9 +53,8 @@ internal class KtFirConstructorSymbol(
 
     override val visibility: Visibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
+
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     override val containingClassIdIfNonLocal: ClassId?
         get() = firRef.withFir { fir -> fir.containingClass()?.classId /* TODO check if local */ }

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

@@ -15,12 +15,11 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 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.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -36,8 +35,8 @@ internal class KtFirEnumEntrySymbol(
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
     override val name: Name get() = firRef.withFir { it.name }
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val containingEnumClassIdIfNonLocal: ClassId?

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

@@ -6,22 +6,17 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+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.symbols.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.KtAnnotationCall
 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.name.ClassId
 
 internal class KtFirFileSymbol(
     fir: FirFile,
@@ -36,9 +31,7 @@ internal class KtFirFileSymbol(
         TODO("Creating pointers for files from library is not supported yet")
     }
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     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

@@ -7,10 +7,8 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 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.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirMemberFunctionSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirTopLevelFunctionSymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.createSignature
@@ -18,14 +16,13 @@ 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.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.symbols.pointers.WrongSymbolForSamConstructor
 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.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
@@ -35,7 +32,6 @@ 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.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirFunctionSymbol(
@@ -47,8 +43,8 @@ internal class KtFirFunctionSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
     override val name: Name get() = firRef.withFir { it.name }
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
@@ -65,17 +61,16 @@ internal class KtFirFunctionSymbol(
 
     override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
+
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     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 receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override val isOperator: Boolean get() = firRef.withFir { it.isOperator }

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

@@ -17,11 +17,10 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 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.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtJavaFieldSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.fir.containingClass
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
@@ -35,8 +34,8 @@ internal class KtFirJavaFieldSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+        firRef.returnType(FirResolvePhase.TYPES, builder)
     }
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }

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

@@ -8,11 +8,9 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.cached
@@ -21,15 +19,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.symbols.pointers.WrongSymbolForSamConstructor
 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.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
@@ -39,7 +36,6 @@ 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.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirKotlinPropertySymbol(
@@ -59,16 +55,16 @@ internal class KtFirKotlinPropertySymbol(
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val typeParameters: List<KtTypeParameterSymbol> by cached {
         fir.typeParameters.map { builder.classifierBuilder.buildTypeParameterSymbol(it) }
     }
 
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
@@ -86,9 +82,7 @@ internal class KtFirKotlinPropertySymbol(
 
     override val visibility: Visibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
 

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

@@ -13,14 +13,13 @@ 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.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.KtLocalVariableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.name.Name
 
 internal class KtFirLocalVariableSymbol(
@@ -39,8 +38,8 @@ internal class KtFirLocalVariableSymbol(
 
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
     override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL
 

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

@@ -15,22 +15,18 @@ 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.symbols.annotations.containsAnnotation
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -68,9 +64,7 @@ internal class KtFirNamedClassOrObjectSymbol(
             else -> possiblyRawVisibility
         }
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     override val isInner: Boolean get() = firRef.withFir { it.isInner }
     override val isData: Boolean get() = firRef.withFir { it.isData }
@@ -82,7 +76,7 @@ internal class KtFirNamedClassOrObjectSymbol(
         fir.companionObject?.let { builder.classifierBuilder.buildNamedClassOrObjectSymbol(it) }
     }
 
-    override val superTypes: List<KtTypeAndAnnotations> by cached {
+    override val superTypes: List<KtType> by cached {
         firRef.superTypesAndAnnotationsListForRegularClass(builder)
     }
 

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

@@ -7,19 +7,16 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 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.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
@@ -31,7 +28,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirPropertyGetterSymbol(
     fir: FirPropertyAccessor,
@@ -51,14 +47,13 @@ internal class KtFirPropertyGetterSymbol(
     override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
     override val hasBody: Boolean get() = firRef.withFir { it.body != null }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
     override val modality: Modality get() = getModality()
     override val visibility: Visibility get() = getVisibility()
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
+
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     /**
      * Returns [CallableId] of the delegated Java method if the corresponding property of this getter is a synthetic Java property.
@@ -70,8 +65,8 @@ internal class KtFirPropertyGetterSymbol(
         } else null
     }
 
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override val valueParameters: List<KtValueParameterSymbol>

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

@@ -7,19 +7,16 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 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.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
@@ -31,7 +28,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
 import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFirPropertySetterSymbol(
     fir: FirPropertyAccessor,
@@ -54,9 +50,8 @@ internal class KtFirPropertySetterSymbol(
     override val modality: Modality get() = getModality()
     override val visibility: Visibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
+
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     /**
      * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
@@ -74,12 +69,12 @@ internal class KtFirPropertySetterSymbol(
 
     override val valueParameters: List<KtValueParameterSymbol> by cached { listOf(parameter) }
 
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }

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

@@ -14,9 +14,9 @@ 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.markers.KtTypeAndAnnotations
 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.declarations.FirCallableDeclaration
 
@@ -33,8 +33,8 @@ internal class KtFirReceiverParameterSymbol(
     private val builder by weakRef(_builder)
     internal val firRef = firRef(fir, resolveState)
 
-    override val type: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.receiverTypeAndAnnotations(builder) ?: throw IllegalStateException("$fir doesn't have an extension receiver.")
+        firRef.receiverType(builder) ?: throw IllegalStateException("$fir doesn't have an extension receiver.")
     }
     override val origin: KtSymbolOrigin get() = firRef.withFir { it.ktSymbolOrigin() }
 

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

@@ -15,12 +15,11 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 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.fir.utils.weakRef
 import org.jetbrains.kotlin.analysis.api.symbols.KtSamConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -34,8 +33,8 @@ internal class KtFirSamConstructorSymbol(
     override val firRef = firRef(fir, resolveState)
     override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.moduleData.session) }
     override val name: Name get() = firRef.withFir { it.name }
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val valueParameters: List<KtValueParameterSymbol> by firRef.withFirAndCache { fir ->
@@ -47,8 +46,8 @@ internal class KtFirSamConstructorSymbol(
     override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
 
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
 
     override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()

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

@@ -7,20 +7,18 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.containsAnnotation
+
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirJavaSyntheticPropertySymbolPointer
 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.markers.KtAnnotationCall
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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
@@ -31,7 +29,6 @@ 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.name.CallableId
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 internal class KtFirSyntheticJavaPropertySymbol(
@@ -45,16 +42,16 @@ internal class KtFirSyntheticJavaPropertySymbol(
 
     override val isVal: Boolean get() = firRef.withFir { it.isVal }
     override val name: Name get() = firRef.withFir { it.name }
-    override val annotatedType: KtTypeAndAnnotations by cached {
+    override val type: KtType by cached {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
     }
 
     override val typeParameters: List<KtTypeParameterSymbol> by cached {
         fir.typeParameters.map { builder.classifierBuilder.buildTypeParameterSymbol(it) }
     }
 
-    override val receiverType: KtTypeAndAnnotations? by cached {
+    override val receiverType: KtType? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+        firRef.receiverType(builder)
     }
     override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null }
     override val initializer: KtConstantValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir ->
@@ -64,9 +61,8 @@ internal class KtFirSyntheticJavaPropertySymbol(
     override val modality: Modality get() = getModality()
     override val visibility: Visibility get() = getVisibility()
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
+
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
 

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

@@ -6,88 +6,44 @@
 package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.KtFirAnnotationCall
 import org.jetbrains.kotlin.analysis.api.fir.utils.FirRefWithValidityCheck
-import org.jetbrains.kotlin.analysis.api.fir.utils.cached
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
-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.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.transformers.resolveSupertypesInTheAir
-import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.coneType
 
-internal class KtFirTypeAndAnnotations<T : FirDeclaration>(
-    private val containingDeclaration: FirRefWithValidityCheck<T>,
-    @Suppress("UNUSED_PARAMETER") typeResolvePhase: FirResolvePhase,
-    private val builder: KtSymbolByFirBuilder,
-    private val typeRef: (T) -> FirTypeRef,
-) : KtTypeAndAnnotations() {
 
-    override val token: ValidityToken get() = containingDeclaration.token
+internal fun FirRefWithValidityCheck<FirClass>.superTypesList(builder: KtSymbolByFirBuilder): List<KtType> =
-
-    override val type: KtType by containingDeclaration.withFirAndCache(ResolveType.CallableReturnType) { fir ->
-        builder.typeBuilder.buildKtType(typeRef(fir))
-    }
-
-    override val annotations: List<KtAnnotationCall> by containingDeclaration.withFirAndCache { fir ->
-        typeRef(fir).annotations.map {
-            KtFirAnnotationCall(containingDeclaration, it)
-        }
-    }
-}
-
-internal class KtSimpleFirTypeAndAnnotations(
-    private val coneType: ConeKotlinType,
-    private val _annotations: List<KtAnnotationCall>,
-    private val builder: KtSymbolByFirBuilder,
-    override val token: ValidityToken
-) : KtTypeAndAnnotations() {
-    override val type: KtType by cached {
-        builder.typeBuilder.buildKtType(coneType)
-    }
-
-    override val annotations: List<KtAnnotationCall> get() = withValidityAssertion { _annotations }
-}
-
-internal fun FirRefWithValidityCheck<FirClass>.superTypesAndAnnotationsList(builder: KtSymbolByFirBuilder): List<KtTypeAndAnnotations> =
     withFir(FirResolvePhase.SUPER_TYPES) { fir ->
-        fir.superTypeRefs.mapToTypeAndAnnotations(this, builder)
+        fir.superTypeRefs.mapToKtType(builder)
     }
 
-internal fun FirRefWithValidityCheck<FirRegularClass>.superTypesAndAnnotationsListForRegularClass(builder: KtSymbolByFirBuilder): List<KtTypeAndAnnotations> {
+internal fun FirRefWithValidityCheck<FirRegularClass>.superTypesAndAnnotationsListForRegularClass(builder: KtSymbolByFirBuilder): List<KtType> {
     return withFir { fir ->
         if (fir.resolvePhase >= FirResolvePhase.SUPER_TYPES) {
-            fir.superTypeRefs.mapToTypeAndAnnotations(this, builder)
+            fir.superTypeRefs.mapToKtType(builder)
         } else null
     } ?: withFirByType(ResolveType.NoResolve) { fir ->
-        fir.resolveSupertypesInTheAir(builder.rootSession).mapToTypeAndAnnotations(this, builder)
+        fir.resolveSupertypesInTheAir(builder.rootSession).mapToKtType(builder)
     }
 }
 
-private fun List<FirTypeRef>.mapToTypeAndAnnotations(
+private fun List<FirTypeRef>.mapToKtType(
-    containingDeclaration: FirRefWithValidityCheck<FirClass>,
     builder: KtSymbolByFirBuilder,
-) = map { typeRef ->
+): List<KtType> = map { typeRef ->
-    val annotations = typeRef.annotations.map { annotation ->
+    builder.typeBuilder.buildKtType(typeRef)
-        KtFirAnnotationCall(containingDeclaration, annotation)
-    }
-    KtSimpleFirTypeAndAnnotations(typeRef.coneType, annotations, builder, containingDeclaration.token)
 }
 
-internal fun FirRefWithValidityCheck<FirTypedDeclaration>.returnTypeAndAnnotations(
+internal fun FirRefWithValidityCheck<FirTypedDeclaration>.returnType(
     typeResolvePhase: FirResolvePhase,
     builder: KtSymbolByFirBuilder
-) = KtFirTypeAndAnnotations(this, typeResolvePhase, builder) { it.returnTypeRef }
+) = withFir(typeResolvePhase) { builder.typeBuilder.buildKtType(it.returnTypeRef) }
 
-internal fun FirRefWithValidityCheck<FirCallableDeclaration>.receiverTypeAndAnnotations(builder: KtSymbolByFirBuilder) = withFir { fir ->
+internal fun FirRefWithValidityCheck<FirCallableDeclaration>.receiverType(
-    fir.receiverTypeRef?.let { _ ->
+    builder: KtSymbolByFirBuilder
-        KtFirTypeAndAnnotations(this, FirResolvePhase.TYPES, builder) {
+): KtType? = withFir(FirResolvePhase.TYPES) { fir ->
-            it.receiverTypeRef ?: error { "Receiver expected for callable declaration but it is null" }
+    fir.receiverTypeRef?.let { receiver ->
-        }
+        builder.typeBuilder.buildKtType(receiver)
     }
 }

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

@@ -7,19 +7,16 @@ package org.jetbrains.kotlin.analysis.api.fir.symbols
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationApplicationForDeclaration
+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.annotations.KtFirAnnotationCall
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.containsAnnotation
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
 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.markers.KtAnnotationCall
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 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.analysis.low.level.api.fir.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.withFirDeclaration
@@ -36,7 +33,6 @@ import org.jetbrains.kotlin.fir.renderWithType
 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.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -92,25 +88,20 @@ internal class KtFirValueParameterSymbol(
     }
 
     override val isVararg: Boolean get() = firRef.withFir { it.isVararg }
-    override val annotatedType: KtTypeAndAnnotations by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir ->
+    override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir ->
         if (fir.isVararg) {
-            val annotations = fir.returnTypeRef.annotations.map { annotation ->
-                KtFirAnnotationCall(firRef, annotation)
-            }
             // There SHOULD always be an array element type (even if it is an error type, e.g., unresolved).
             val arrayElementType = fir.returnTypeRef.coneType.arrayElementType()
                 ?: error("No array element type for vararg value parameter: ${fir.renderWithType()}")
-            KtSimpleFirTypeAndAnnotations(arrayElementType, annotations, builder, firRef.token)
+            builder.typeBuilder.buildKtType(arrayElementType)
         } else {
-            firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+            firRef.returnType(FirResolvePhase.TYPES, builder)
         }
     }
 
     override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null }
 
-    override val annotations: List<KtAnnotationCall> by cached { firRef.toAnnotationsList() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
-    override fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
         KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }

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

@@ -8,7 +8,9 @@ package org.jetbrains.kotlin.analysis.api.fir.types
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForType
 import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
@@ -51,6 +53,10 @@ internal class KtFirUsualClassType(
         }
     }
 
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
     override fun equals(other: Any?) = typeEquals(other)
@@ -73,6 +79,10 @@ internal class KtFirFunctionalType(
         }
     }
 
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
     override val isSuspend: Boolean get() = withValidityAssertion { coneType.isSuspendFunctionType(builder.rootSession) }
@@ -116,6 +126,10 @@ internal class KtFirClassErrorType(
     override val error: String get() = withValidityAssertion { coneType.diagnostic.reason }
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override val candidateClassSymbols: Collection<KtClassLikeSymbol> by cached {
         val symbols = coneType.diagnostic.getCandidateSymbols().filterIsInstance<FirClassLikeSymbol<*>>()
         symbols.map { builder.classifierBuilder.buildClassLikeSymbol(it.fir) }
@@ -129,9 +143,17 @@ internal class KtFirClassErrorType(
 internal class KtFirCapturedType(
     override val coneType: ConeCapturedType,
     override val token: ValidityToken,
+    private val builder: KtSymbolByFirBuilder,
 ) : KtCapturedType(), KtFirType {
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
+
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
+
+
     override fun equals(other: Any?) = typeEquals(other)
     override fun hashCode() = typeHashcode()
 }
@@ -142,6 +164,9 @@ internal class KtFirDefinitelyNotNullType(
     private val builder: KtSymbolByFirBuilder,
 ) : KtDefinitelyNotNullType(), KtFirType {
     override val original: KtType by cached { builder.typeBuilder.buildKtType(this.coneType.original) }
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
     override fun equals(other: Any?) = typeEquals(other)
@@ -159,6 +184,10 @@ internal class KtFirTypeParameterType(
             ?: error("Type parameter ${coneType.lookupTag} was not found")
     }
 
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
@@ -174,7 +203,9 @@ internal class KtFirFlexibleType(
 
     override val lowerBound: KtType by cached { builder.typeBuilder.buildKtType(coneType.lowerBound) }
     override val upperBound: KtType by cached { builder.typeBuilder.buildKtType(coneType.upperBound) }
-
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
@@ -190,7 +221,9 @@ internal class KtFirIntersectionType(
     override val conjuncts: List<KtType> by cached {
         coneType.intersectedTypes.map { conjunct -> builder.typeBuilder.buildKtType(conjunct) }
     }
-
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }
@@ -213,6 +246,10 @@ internal class KtFirIntegerLiteralType(
         }
     }
 
+    override val annotationsList: KtAnnotationsList by cached {
+        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
+    }
+
     override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
 
     override fun asStringForDebugging(): String = withValidityAssertion { coneType.render() }

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/annotations/KtEmptyAnnotationsList.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2010-2021 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.impl.base.annotations
+
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.withValidityAssertion
+import org.jetbrains.kotlin.name.ClassId
+
+class KtEmptyAnnotationsList(override val token: ValidityToken) : KtAnnotationsList() {
+    override val annotations: List<KtAnnotationApplication>
+        get() = withValidityAssertion { emptyList() }
+
+    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion { false }
+
+    override fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> =
+        withValidityAssertion { emptyList() }
+
+    override val annotationClassIds: Collection<ClassId>
+        get() = withValidityAssertion { emptyList() }
+}

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/symbolDeclarationOverridesProvider/AbstractOverriddenDeclarationProviderTest.kt

@@ -51,7 +51,7 @@ abstract class AbstractOverriddenDeclarationProviderTest(
             symbol.valueParameters.forEachIndexed { index, parameter ->
                 append(parameter.name.identifier)
                 append(": ")
-                append(parameter.annotatedType.type.render(KtTypeRendererOptions.SHORT_NAMES))
+                append(parameter.type.render(KtTypeRendererOptions.SHORT_NAMES))
                 if (index != symbol.valueParameters.lastIndex) {
                     append(", ")
                 }
@@ -59,7 +59,7 @@ abstract class AbstractOverriddenDeclarationProviderTest(
             append(")")
         }
         append(": ")
-        append(symbol.annotatedType.type.render(KtTypeRendererOptions.SHORT_NAMES))
+        append(symbol.type.render(KtTypeRendererOptions.SHORT_NAMES))
     }
 
     private fun getPath(symbol: KtCallableSymbol): String = when (symbol) {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/fir/AbstractResolveCallTest.kt

@@ -78,7 +78,7 @@ private fun KtAnalysisSession.stringRepresentation(call: KtCall): String {
             )
             append("(")
             (this@stringValue as? KtFunctionSymbol)?.receiverType?.let { receiver ->
-                append("<extension receiver>: ${receiver.type.render()}")
+                append("<extension receiver>: ${receiver.render()}")
                 if (valueParameters.isNotEmpty()) append(", ")
             }
 
@@ -89,11 +89,11 @@ private fun KtAnalysisSession.stringRepresentation(call: KtCall): String {
             }
             valueParameters.joinTo(this) { it.stringValue() }
             append(")")
-            append(": ${annotatedType.type.render()}")
+            append(": ${type.render()}")
         }
-        is KtValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${annotatedType.type.render()}"
+        is KtValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${type.render()}"
         is KtTypeParameterSymbol -> this.nameOrAnonymous.asString()
-        is KtVariableSymbol -> "${if (isVal) "val" else "var"} $name: ${annotatedType.type.render()}"
+        is KtVariableSymbol -> "${if (isVal) "val" else "var"} $name: ${type.render()}"
         is KtSuccessCallTarget -> symbol.stringValue()
         is KtErrorCallTarget -> "ERR<${this.diagnostic.defaultMessage}, [${candidates.joinToString { it.stringValue() }}]>"
         is Boolean -> toString()

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtAnnotated.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.name.ClassId
+
+public interface KtAnnotated {
+    public val annotationsList: KtAnnotationsList
+}
+
+public val KtAnnotated.annotations: List<KtAnnotationApplication>
+    get() = annotationsList.annotations
+
+public fun KtAnnotated.containsAnnotation(classId: ClassId): Boolean =
+    annotationsList.containsAnnotation(classId)
+
+public fun KtAnnotated.annotationsByClassId(classId: ClassId): List<KtAnnotationApplication> =
+    annotationsList.annotationsByClassId(classId)
+
+public val KtAnnotated.annotationClassIds: Collection<ClassId>
+    get() = annotationsList.annotationClassIds

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtAnnotationApplication.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.psi.KtCallElement
+
+public abstract class KtAnnotationApplication : ValidityTokenOwner {
+    public abstract val classId: ClassId?
+    public abstract val useSiteTarget: AnnotationUseSiteTarget?
+    public abstract val psi: KtCallElement?
+    public abstract val arguments: List<KtNamedConstantValue>
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtAnnotationsList.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.name.ClassId
+
+public abstract class KtAnnotationsList : ValidityTokenOwner {
+    public abstract val annotations: List<KtAnnotationApplication>
+    public abstract fun containsAnnotation(classId: ClassId): Boolean
+    public abstract fun annotationsByClassId(classId: ClassId): List<KtAnnotationApplication>
+    public abstract val annotationClassIds: Collection<ClassId>
+}
+

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtNamedConstantValue.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2010-2021 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.annotations
+
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+
+public data class KtNamedConstantValue(val name: String, val expression: KtConstantValue)

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

@@ -7,6 +7,10 @@ package org.jetbrains.kotlin.analysis.api.symbols
 
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.annotations
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolInfoProviderMixIn
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.analysis.api.types.KtClassErrorType
@@ -124,19 +128,17 @@ public object DebugSymbolRenderer {
     }
 
     private fun Block.renderType(type: KtType) {
+        if (type.annotations.isNotEmpty()) {
+            renderList(type.annotations)
+            append(' ')
+        }
         when (type) {
             is KtClassErrorType -> append("ERROR_TYPE")
             else -> append(type.asStringForDebugging())
         }
     }
 
-    private fun Block.renderTypeAndAnnotations(type: KtTypeAndAnnotations) {
+    private fun Block.renderAnnotationApplication(call: KtAnnotationApplication) {
-        renderList(type.annotations)
-        append(' ')
-        renderType(type.type)
-    }
-
-    private fun Block.renderAnnotationCall(call: KtAnnotationCall) {
         renderValue(call.classId)
         append('(')
         call.arguments.sortedBy { it.name }.forEachIndexed { index, value ->
@@ -166,10 +168,10 @@ public object DebugSymbolRenderer {
             // Symbol-related values
             is KtSymbol -> renderSymbolTag(value)
             is KtType -> renderType(value)
-            is KtTypeAndAnnotations -> renderTypeAndAnnotations(value)
             is KtConstantValue -> renderConstantValue(value)
             is KtNamedConstantValue -> renderNamedConstantValue(value)
-            is KtAnnotationCall -> renderAnnotationCall(value)
+            is KtAnnotationApplication -> renderAnnotationApplication(value)
+            is KtAnnotationsList -> renderAnnotationsList(value)
             // Other custom values
             is Name -> append(value.asString())
             is FqName -> append(value.asString())
@@ -188,6 +190,10 @@ public object DebugSymbolRenderer {
         }
     }
 
+    private fun Block.renderAnnotationsList(value: KtAnnotationsList) {
+        renderList(value.annotations)
+    }
+
     private fun getSymbolApiClass(symbol: KtSymbol): KClass<*> {
         var current: Class<in KtSymbol> = symbol.javaClass
 

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

@@ -6,15 +6,15 @@
 package org.jetbrains.kotlin.analysis.api.symbols
 
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.name.CallableId
 
 public abstract class KtCallableSymbol : KtSymbol, KtSymbolWithKind {
     public abstract val callableIdIfNonLocal: CallableId?
-    public abstract val annotatedType: KtTypeAndAnnotations
+    public abstract val type: KtType
 
-    public abstract val receiverType: KtTypeAndAnnotations?
+    public abstract val receiverType: KtType?
     public abstract val isExtension: Boolean
 
     abstract override fun createPointer(): KtSymbolPointer<KtCallableSymbol>
@@ -25,5 +25,5 @@ public abstract class KtCallableSymbol : KtSymbol, KtSymbolWithKind {
  * `String` receiver parameter is such a symbol.
  */
 public abstract class KtReceiverParameterSymbol : KtSymbol {
-    public abstract val type: KtTypeAndAnnotations
+    public abstract val type: KtType
 }

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

@@ -52,7 +52,7 @@ public sealed class KtClassOrObjectSymbol : KtClassLikeSymbol(),
     KtSymbolWithMembers {
 
     public abstract val classKind: KtClassKind
-    public abstract val superTypes: List<KtTypeAndAnnotations>
+    public abstract val superTypes: List<KtType>
 
     abstract override fun createPointer(): KtSymbolPointer<KtClassOrObjectSymbol>
 }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.symbols
 
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 
@@ -66,7 +67,7 @@ public abstract class KtConstructorSymbol : KtFunctionLikeSymbol(),
     final override val callableIdIfNonLocal: CallableId? get() = null
     final override val symbolKind: KtSymbolKind get() = KtSymbolKind.CLASS_MEMBER
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
 
     abstract override fun createPointer(): KtSymbolPointer<KtConstructorSymbol>
 }

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

@@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
@@ -37,7 +38,7 @@ public abstract class KtBackingFieldSymbol : KtVariableLikeSymbol() {
     final override val origin: KtSymbolOrigin get() = KtSymbolOrigin.PROPERTY_BACKING_FIELD
     final override val callableIdIfNonLocal: CallableId? get() = null
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
 
     abstract override fun createPointer(): KtSymbolPointer<KtVariableLikeSymbol>
 
@@ -50,7 +51,7 @@ public abstract class KtBackingFieldSymbol : KtVariableLikeSymbol() {
 public abstract class KtEnumEntrySymbol : KtVariableLikeSymbol(), KtSymbolWithMembers, KtSymbolWithKind {
     final override val symbolKind: KtSymbolKind get() = KtSymbolKind.CLASS_MEMBER
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
     public abstract val containingEnumClassIdIfNonLocal: ClassId?
 
     abstract override fun createPointer(): KtSymbolPointer<KtEnumEntrySymbol>
@@ -69,7 +70,7 @@ public abstract class KtJavaFieldSymbol :
     KtSymbolWithKind {
     final override val symbolKind: KtSymbolKind get() = KtSymbolKind.CLASS_MEMBER
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
     public abstract val isStatic: Boolean
 
     abstract override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol>
@@ -126,7 +127,7 @@ public abstract class KtSyntheticJavaPropertySymbol : KtPropertySymbol() {
 public abstract class KtLocalVariableSymbol : KtVariableSymbol(), KtSymbolWithKind {
     final override val callableIdIfNonLocal: CallableId? get() = null
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
 
     abstract override fun createPointer(): KtSymbolPointer<KtLocalVariableSymbol>
 }
@@ -135,7 +136,7 @@ public abstract class KtValueParameterSymbol : KtVariableLikeSymbol(), KtSymbolW
     final override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL
     final override val callableIdIfNonLocal: CallableId? get() = null
     final override val isExtension: Boolean get() = false
-    final override val receiverType: KtTypeAndAnnotations? get() = null
+    final override val receiverType: KtType? get() = null
 
     public abstract val hasDefaultValue: Boolean
     public abstract val isVararg: Boolean

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtAnnotatedSymbol.kt

@@ -5,24 +5,9 @@
 
 package org.jetbrains.kotlin.analysis.api.symbols.markers
 
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotated
-import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.psi.KtCallElement
 
-public abstract class KtAnnotationCall : ValidityTokenOwner {
-    public abstract val classId: ClassId?
-    public abstract val useSiteTarget: AnnotationUseSiteTarget?
-    public abstract val psi: KtCallElement?
-    public abstract val arguments: List<KtNamedConstantValue>
-}
 
-public data class KtNamedConstantValue(val name: String, val expression: KtConstantValue)
+public interface KtAnnotatedSymbol : KtSymbol, KtAnnotated
-
-public interface KtAnnotatedSymbol : KtSymbol {
-    public val annotations: List<KtAnnotationCall>
-
-    public fun containsAnnotation(classId: ClassId): Boolean
-    public val annotationClassIds: Collection<ClassId>
-}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtConstantValue.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.symbols.markers
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtCallElement

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtTypeAndAnnotations.kt

@@ -1,33 +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.symbols.markers
-
-import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
-import org.jetbrains.kotlin.analysis.api.types.KtType
-
-public abstract class KtTypeAndAnnotations : ValidityTokenOwner {
-    public abstract val type: KtType
-    public abstract val annotations: List<KtAnnotationCall>
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
-
-        other as KtTypeAndAnnotations
-
-        if (token != other.token) return false
-        if (type != other.type) return false
-        if (annotations != other.annotations) return false
-
-        return true
-    }
-
-    override fun hashCode(): Int {
-        var result = token.hashCode()
-        result = 31 * result + type.hashCode()
-        result = 31 * result + annotations.hashCode()
-        return result
-    }
-}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/types/KtType.kt

@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.analysis.api.types
 
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotated
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.ConeNullability
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
-public sealed interface KtType : ValidityTokenOwner {
+public sealed interface KtType : ValidityTokenOwner, KtAnnotated {
     public val nullability: KtTypeNullability
     public fun asStringForDebugging(): String
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/FirAnnotationParameterList.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightIdentifier
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedConstantValue
 import org.jetbrains.kotlin.psi.KtElement
 
 internal class FirAnnotationParameterList(

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/FirLightAnnotationForAnnotationCall.kt

@@ -10,12 +10,12 @@ import com.intellij.psi.PsiAnnotationMemberValue
 import com.intellij.psi.PsiAnnotationParameterList
 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.PsiImplUtil
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotationCall
 import org.jetbrains.kotlin.psi.KtCallElement
 
 internal class FirLightAnnotationForAnnotationCall(
-    private val annotationCall: KtAnnotationCall,
+    private val annotationCall: KtAnnotationApplication,
     parent: PsiElement,
 ) : FirLightAbstractAnnotation(parent) {
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/FirLightSimpleAnnotation.kt

@@ -9,7 +9,7 @@ import com.intellij.psi.PsiAnnotationMemberValue
 import com.intellij.psi.PsiAnnotationParameterList
 import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.PsiImplUtil
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.psi.KtCallElement
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt

@@ -10,6 +10,7 @@ import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.annotations.Nullable
+import org.jetbrains.kotlin.analysis.api.annotations.annotations
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/FirLightClassForEnumEntry.kt

@@ -82,7 +82,7 @@ internal class FirLightClassForEnumEntry(
 
     private val _extendsList: PsiReferenceList? by lazyPub {
         val mappedType = analyzeWithSymbolAsContext(enumEntrySymbol) {
-            enumEntrySymbol.annotatedType.type.asPsiType(this@FirLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType
+            enumEntrySymbol.type.asPsiType(this@FirLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType
                 ?: return@lazyPub null
         }
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/firLightClassUtils.kt

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
 import org.jetbrains.kotlin.analysis.api.tokens.HackToForceAllowRunningAnalyzeOnEDT
 import org.jetbrains.kotlin.analysis.api.tokens.hackyAllowRunningOnEdt
@@ -306,7 +305,7 @@ internal fun FirLightClassBase.createField(
     )
 }
 
-internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtTypeAndAnnotations>): PsiReferenceList {
+internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
 
     val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST
 
@@ -334,9 +333,8 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su
 
     //TODO Add support for kotlin.collections.
     superTypes.asSequence()
-        .filter { it.type.needToAddTypeIntoList() }
+        .filter { it.needToAddTypeIntoList() }
-        .mapNotNull { typeAnnotated ->
+        .mapNotNull { type ->
-            val type = typeAnnotated.type
             if (type !is KtNonErrorClassType) return@mapNotNull null
             analyzeWithSymbolAsContext(type.classSymbol) {
                 mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true)

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldEnumEntry.kt

@@ -66,7 +66,7 @@ internal class FirLightFieldForEnumEntry(
 
     private val _type: PsiType by lazyPub {
         analyzeWithSymbolAsContext(enumEntrySymbol) {
-            enumEntrySymbol.annotatedType.type.asPsiType(this@FirLightFieldForEnumEntry)
+            enumEntrySymbol.type.asPsiType(this@FirLightFieldForEnumEntry)
         } ?: nonExistentType()
     }
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt

@@ -38,7 +38,7 @@ internal class FirLightFieldForPropertySymbol(
                         it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
                     }
                 else -> {
-                    propertySymbol.annotatedType.type.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
+                    propertySymbol.type.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
                 }
             }
         } ?: nonExistentType()
@@ -92,7 +92,7 @@ internal class FirLightFieldForPropertySymbol(
 
         val nullability = if (!(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit)) {
             analyzeWithSymbolAsContext(propertySymbol) {
-                getTypeNullability(propertySymbol.annotatedType.type)
+                getTypeNullability(propertySymbol.type)
             }
         } else NullabilityType.Unknown
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt

@@ -26,14 +26,6 @@ internal fun <L : Any> L.invalidAccess(): Nothing =
     error("Cls delegate shouldn't be accessed for fir light classes! Qualified name: ${javaClass.name}")
 
 
-internal fun KtAnalysisSession.mapSuperType(
-    type: KtTypeAndAnnotations,
-    psiContext: PsiElement,
-    kotlinCollectionAsIs: Boolean = false
-): PsiClassType? {
-    return mapSuperType(type.type, psiContext, kotlinCollectionAsIs)
-}
-
 internal fun KtAnalysisSession.mapSuperType(
     type: KtType,
     psiContext: PsiElement,

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightAccessorMethodForSymbol.kt

@@ -75,7 +75,7 @@ internal class FirLightAccessorMethodForSymbol(
         val nullabilityType = if (nullabilityApplicable) {
             analyzeWithSymbolAsContext(containingPropertySymbol) {
                 getTypeNullability(
-                    containingPropertySymbol.annotatedType.type
+                    containingPropertySymbol.type
                 )
             }
         } else NullabilityType.Unknown
@@ -151,7 +151,7 @@ internal class FirLightAccessorMethodForSymbol(
     private val _returnedType: PsiType by lazyPub {
         if (!isGetter) return@lazyPub PsiType.VOID
         analyzeWithSymbolAsContext(containingPropertySymbol) {
-            containingPropertySymbol.annotatedType.type.asPsiType(
+            containingPropertySymbol.type.asPsiType(
                 this@FirLightAccessorMethodForSymbol,
                 KtTypeMappingMode.RETURN_TYPE,
                 containingClass.isAnnotationType

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/FirLightSimpleMethodForSymbol.kt

@@ -66,7 +66,7 @@ internal class FirLightSimpleMethodForSymbol(
                         isVoidReturnType ->
                             return@l NullabilityType.Unknown
                         else ->
-                            functionSymbol.annotatedType.type
+                            functionSymbol.type
                     }
                 getTypeNullability(ktType)
             }
@@ -131,7 +131,7 @@ internal class FirLightSimpleMethodForSymbol(
     override fun isConstructor(): Boolean = false
 
     private val isVoidReturnType: Boolean
-        get() = functionSymbol.annotatedType.type.run {
+        get() = functionSymbol.type.run {
             isUnit && nullabilityType != NullabilityType.Nullable
         }
 
@@ -144,7 +144,7 @@ internal class FirLightSimpleMethodForSymbol(
                     isVoidReturnType ->
                         return@lazyPub PsiType.VOID
                     else ->
-                        functionSymbol.annotatedType.type
+                        functionSymbol.type
                 }
             ktType.asPsiType(
                 this@FirLightSimpleMethodForSymbol,

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterBaseForSymbol.kt

@@ -37,7 +37,7 @@ internal abstract class FirLightParameterBaseForSymbol(
             return if (nullabilityApplicable) {
                 analyzeWithSymbolAsContext(parameterSymbol) {
                     getTypeNullability(
-                        parameterSymbol.annotatedType.type
+                        parameterSymbol.type
                     )
                 }
             } else NullabilityType.Unknown
@@ -47,7 +47,7 @@ internal abstract class FirLightParameterBaseForSymbol(
 
     private val _type by lazyPub {
         val convertedType = analyzeWithSymbolAsContext(parameterSymbol) {
-            val ktType = parameterSymbol.annotatedType.type
+            val ktType = parameterSymbol.type
             val typeMappingMode = when {
                 ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT
                 // TODO: extract type mapping mode from annotation?

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightParameterForReceiver.kt

@@ -9,17 +9,18 @@ import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiIdentifier
 import com.intellij.psi.PsiModifierList
 import com.intellij.psi.PsiType
+import org.jetbrains.kotlin.analysis.api.annotations.annotations
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.analysis.api.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtTypeAndAnnotations
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.psi.KtParameter
 
 internal class FirLightParameterForReceiver private constructor(
-    private val receiverTypeAndAnnotations: KtTypeAndAnnotations,
+    private val receiverType: KtType,
     private val context: KtSymbol,
     methodName: String,
     method: FirLightMethod
@@ -37,7 +38,7 @@ internal class FirLightParameterForReceiver private constructor(
             val extensionTypeAndAnnotations = callableSymbol.receiverType ?: return null
 
             return FirLightParameterForReceiver(
-                receiverTypeAndAnnotations = extensionTypeAndAnnotations,
+                receiverType = extensionTypeAndAnnotations,
                 context = callableSymbol,
                 methodName = callableSymbol.name.asString(),
                 method = method
@@ -59,7 +60,7 @@ internal class FirLightParameterForReceiver private constructor(
     override val kotlinOrigin: KtParameter? = null
 
     private val _annotations: List<PsiAnnotation> by lazyPub {
-        receiverTypeAndAnnotations.annotations.map {
+        receiverType.annotations.map {
             FirLightAnnotationForAnnotationCall(it, this)
         }
     }
@@ -71,7 +72,7 @@ internal class FirLightParameterForReceiver private constructor(
 
     private val _type: PsiType by lazyPub {
         analyzeWithSymbolAsContext(context) {
-            receiverTypeAndAnnotations.type.asPsiType(this@FirLightParameterForReceiver)
+            receiverType.asPsiType(this@FirLightParameterForReceiver)
         } ?: nonExistentType()
     }
 
@@ -80,7 +81,7 @@ internal class FirLightParameterForReceiver private constructor(
     override fun equals(other: Any?): Boolean =
         this === other ||
                 (other is FirLightParameterForReceiver &&
-                        receiverTypeAndAnnotations == other.receiverTypeAndAnnotations)
+                        receiverType == other.receiverType)
 
     override fun hashCode(): Int = kotlinOrigin.hashCode()
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/FirLightSuspendContinuationParameter.kt

@@ -35,7 +35,7 @@ internal class FirLightSuspendContinuationParameter(
     private val _type by lazyPub {
         analyzeWithSymbolAsContext(functionSymbol) {
             buildClassType(StandardClassIds.Continuation) {
-                argument(functionSymbol.annotatedType.type)
+                argument(functionSymbol.type)
             }.asPsiType(this@FirLightSuspendContinuationParameter)
         } ?: nonExistentType()
     }