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

2021-11-18 14:50:13 +01:00
parent 83d2d2cfcf
commit a5a5ff39d6
101 changed files with 807 additions and 717 deletions
@@ -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)
+            }
+        }
+    }
+}
@@ -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 }

@@ -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.descriptors.symbols.descriptorBased.base.maybeLocalClassId
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
+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())
-    }
 }
@@ -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
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
@@ -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>
-        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisContext) } }
+    override val superTypes: List<KtType>
+        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtType(analysisContext) } }

    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
@@ -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
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnType.toKtType(analysisContext) }

    override val typeParameters: List<KtTypeParameterSymbol>
        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }
@@ -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
-        get() = withValidityAssertion { propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        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?
-        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        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>
-        get() = withValidityAssertion { emptyList() }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> {
        withValidityAssertion {
@@ -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.symbols.markers.KtTypeAndAnnotations
+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.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
-        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        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?
-        get() = withValidityAssertion { propertyDescriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        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>
-        get() = withValidityAssertion { emptyList() }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    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
-            get() = withValidityAssertion { propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+        override val type: KtType
+            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>
-            get() = withValidityAssertion { emptyList() }
+        override val annotationsList: KtAnnotationsList
+            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 {
@@ -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
-        get() = withValidityAssertion { enumDescriptor.defaultType.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { enumDescriptor.defaultType.toKtType(analysisContext) }

    override val name: Name
        get() = withValidityAssertion { descriptor.name }
@@ -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
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override val isExtension: Boolean
        get() = withValidityAssertion { descriptor.isExtension }
@@ -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
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnType.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> = withValidityAssertion {
        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
@@ -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
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override val typeParameters: List<KtTypeParameterSymbol>
        get() = withValidityAssertion { descriptor.typeParameters.map { it.toKtTypeParameter(analysisContext) } }
@@ -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
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion { KtSymbolKind.LOCAL }
@@ -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?
@@ -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
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
@@ -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
-        get() = withValidityAssertion { analysisContext.builtIns.unitType.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        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?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
        withValidityAssertion {
@@ -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
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override val isExtension: Boolean
        get() = withValidityAssertion { descriptor.isExtension }
@@ -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
-        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtVariableLikeSymbol> = withValidityAssertion {
        val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi()
@@ -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
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }


    override val typeParameters: List<KtTypeParameterSymbol>
@@ -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
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

-    override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
+    override val receiverType: KtType?
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext) }

    override val typeParameters: List<KtTypeParameterSymbol>
        get() = withValidityAssertion { descriptor.typeParameters.map { it.toKtTypeParameter(analysisContext) } }
@@ -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 {
@@ -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)
@@ -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
@@ -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 {
@@ -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
@@ -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.symbols.markers.KtTypeAndAnnotations
+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.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
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        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>
-        get() = withValidityAssertion { emptyList() }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
        return KtFe10NeverRestoringSymbolPointer()
@@ -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>
-        get() = withValidityAssertion { emptyList() }
-
-    override fun containsAnnotation(classId: ClassId): Boolean {
-        withValidityAssertion {
-            return false
-        }
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    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
-            get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+        override val type: KtType
+            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>
-            get() = withValidityAssertion { emptyList() }
-
-        override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-            return false
-        }
-
-        override val annotationClassIds: Collection<ClassId>
-            get() = withValidityAssertion { emptyList() }
+        override val annotationsList: KtAnnotationsList
+            get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

        override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
            return KtFe10NeverRestoringSymbolPointer()
@@ -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.symbols.markers.KtTypeAndAnnotations
+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.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
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        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>
-        get() = withValidityAssertion { emptyList() }
-
-    override fun containsAnnotation(classId: ClassId): Boolean = withValidityAssertion {
-        return false
-    }
-
-    override val annotationClassIds: Collection<ClassId>
-        get() = withValidityAssertion { emptyList() }
+    override val annotationsList: KtAnnotationsList
+        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
        return KtFe10NeverRestoringSymbolPointer()
@@ -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()
            }
        }

@@ -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
-        get() = withValidityAssertion { descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        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
@@ -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
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        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
            }
@@ -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
@@ -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
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val isVal: Boolean
        get() = withValidityAssertion { !psi.isVar }
@@ -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
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
+    override val type: KtType
+        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val isVal: Boolean
        get() = withValidityAssertion { !psi.isMutable }
@@ -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?
@@ -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)
-                !psi.property.isTopLevel -> createErrorTypeAndAnnotations()
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext)
+                !psi.property.isTopLevel -> createErrorType()
                else -> null
            }
        }
@@ -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)
-                psi.property.isExtensionDeclaration() -> createErrorTypeAndAnnotations()
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtType(analysisContext)
+                psi.property.isExtensionDeclaration() -> createErrorType()
                else -> null
            }
        }
@@ -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
@@ -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
@@ -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
 }
@@ -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) }
-        }
-}
@@ -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
@@ -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)
                }
@@ -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.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.fir.psi
 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,
-) : KtAnnotationCall() {
+    private val useSiteSession: FirSession,
+    private val annotation: FirAnnotation,
+    override val token: ValidityToken,
+) : KtAnnotationApplication() {

-    private val annotationCallRef by weakRef(annotation)
-
-    override val token: ValidityToken get() = containingDeclaration.token
-
-    override val psi: KtCallElement? by containingDeclaration.withFirAndCache { fir ->
-        annotationCallRef.findPsi(fir.moduleData.session) as? KtCallElement
-    }
+    override val psi: KtCallElement? by cached { annotation.psi as? KtCallElement }

    override val classId: ClassId? by cached {
-        containingDeclaration.withFirByType(ResolveType.AnnotationType) { fir ->
-            annotationCallRef.getClassId(fir.moduleData.session)
+        containingDeclaration.withFirByType(ResolveType.AnnotationType) {
+            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),
-            fir.moduleData.session,
+            mapAnnotationParameters(annotation, useSiteSession),
+            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()
    }
-}
+}
@@ -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()
+    }
+}
@@ -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)
+            }
+        }
+    }
+}
@@ -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)
+            }
+        }
+    }
+}
+
@@ -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
@@ -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? =
@@ -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()
    }
 }
@@ -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
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        firRef.receiverType(builder)
    }

    override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> {
@@ -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.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }

-    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)
@@ -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 {
-        propertyFirRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    override val type: KtType by cached {
+        propertyFirRef.returnType(FirResolvePhase.TYPES, builder)
    }

    override val owningProperty: KtKotlinPropertySymbol by propertyFirRef.withFirAndCache { fir ->
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+

    override val containingClassIdIfNonLocal: ClassId?
        get() = firRef.withFir { fir -> fir.containingClass()?.classId /* TODO check if local */ }
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
    }

    override val containingEnumClassIdIfNonLocal: ClassId?
@@ -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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }

    override fun equals(other: Any?): Boolean = symbolEquals(other)
    override fun hashCode(): Int = symbolHashCode()
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+

    override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend }
    override val isOverride: Boolean get() = firRef.withFir { it.isOverride }
    override val isInfix: Boolean get() = firRef.withFir { it.isInfix }
    override val isStatic: Boolean get() = firRef.withFir { it.isStatic }

-    override val receiverType: KtTypeAndAnnotations? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        firRef.receiverType(builder)
    }

    override val isOperator: Boolean get() = firRef.withFir { it.isOperator }
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder)
+    override val type: KtType by cached {
+        firRef.returnType(FirResolvePhase.TYPES, builder)
    }
    override val isVal: Boolean get() = firRef.withFir { it.isVal }
    override val name: Name get() = firRef.withFir { it.name }
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }

    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()

@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
    }
    override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL

@@ -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.symbols.annotations.getAnnotationClassIds
-import org.jetbrains.kotlin.analysis.api.fir.symbols.annotations.toAnnotationsList
+import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
 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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }

    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)
    }

@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+

    /**
     * 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 {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        firRef.receiverType(builder)
    }

    override val valueParameters: List<KtValueParameterSymbol>
@@ -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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+

    /**
     * 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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        firRef.returnType(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
    }

-    override val receiverType: KtTypeAndAnnotations? by cached {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        firRef.receiverType(builder)
    }

    override val hasStableParameterNames: Boolean = firRef.withFir { it.getHasStableParameterNames(it.moduleData.session) }
@@ -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 {
-        firRef.receiverTypeAndAnnotations(builder) ?: throw IllegalStateException("$fir doesn't have an extension receiver.")
+    override val type: KtType by cached {
+        firRef.receiverType(builder) ?: throw IllegalStateException("$fir doesn't have an extension receiver.")
    }
    override val origin: KtSymbolOrigin get() = firRef.withFir { it.ktSymbolOrigin() }

@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        firRef.receiverType(builder)
    }

    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()
@@ -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 {
-        firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder)
+    override val type: KtType by cached {
+        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 {
-        firRef.receiverTypeAndAnnotations(builder)
+    override val receiverType: KtType? by cached {
+        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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+        override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }
+

    override val callableIdIfNonLocal: CallableId? get() = getCallableIdIfNonLocal()

@@ -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
-
-    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> =
+internal fun FirRefWithValidityCheck<FirClass>.superTypesList(builder: KtSymbolByFirBuilder): List<KtType> =
    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(
-    containingDeclaration: FirRefWithValidityCheck<FirClass>,
+private fun List<FirTypeRef>.mapToKtType(
    builder: KtSymbolByFirBuilder,
-) = map { typeRef ->
-    val annotations = typeRef.annotations.map { annotation ->
-        KtFirAnnotationCall(containingDeclaration, annotation)
-    }
-    KtSimpleFirTypeAndAnnotations(typeRef.coneType, annotations, builder, containingDeclaration.token)
+): List<KtType> = map { typeRef ->
+    builder.typeBuilder.buildKtType(typeRef)
 }

-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 ->
-    fir.receiverTypeRef?.let { _ ->
-        KtFirTypeAndAnnotations(this, FirResolvePhase.TYPES, builder) {
-            it.receiverTypeRef ?: error { "Receiver expected for callable declaration but it is null" }
-        }
+internal fun FirRefWithValidityCheck<FirCallableDeclaration>.receiverType(
+    builder: KtSymbolByFirBuilder
+): KtType? = withFir(FirResolvePhase.TYPES) { fir ->
+    fir.receiverTypeRef?.let { receiver ->
+        builder.typeBuilder.buildKtType(receiver)
    }
 }
@@ -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 fun containsAnnotation(classId: ClassId): Boolean = firRef.containsAnnotation(classId)
-    override val annotationClassIds: Collection<ClassId> by cached { firRef.getAnnotationClassIds() }
+    override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firRef, resolveState.rootModuleSession, token) }

    override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
        KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
@@ -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() }
@@ -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() }
+}
@@ -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) {
@@ -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()
@@ -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
@@ -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>
+}
@@ -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>
+}
+
@@ -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)
@@ -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) {
-        renderList(type.annotations)
-        append(' ')
-        renderType(type.type)
-    }
-
-    private fun Block.renderAnnotationCall(call: KtAnnotationCall) {
+    private fun Block.renderAnnotationApplication(call: KtAnnotationApplication) {
        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

@@ -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
 }
@@ -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>
 }
@@ -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>
 }
@@ -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
@@ -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.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotated
+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 {
-    public val annotations: List<KtAnnotationCall>
-
-    public fun containsAnnotation(classId: ClassId): Boolean
-    public val annotationClassIds: Collection<ClassId>
-}
+public interface KtAnnotatedSymbol : KtSymbol, KtAnnotated
@@ -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
@@ -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
-    }
-}
@@ -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
 }
@@ -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(
@@ -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) {

@@ -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

@@ -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
@@ -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
        }

@@ -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() }
-        .mapNotNull { typeAnnotated ->
-            val type = typeAnnotated.type
+        .filter { it.needToAddTypeIntoList() }
+        .mapNotNull { type ->
            if (type !is KtNonErrorClassType) return@mapNotNull null
            analyzeWithSymbolAsContext(type.classSymbol) {
                mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true)
@@ -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()
    }

@@ -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

@@ -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,
@@ -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
@@ -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,
@@ -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?
@@ -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()

@@ -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()
    }
--- a/Show More
+++ b/Show More