[FIR] Split FirAnnotation into FirAnnotation and FirAnnotationCall

FirAnnotation represents simple annotation placed on some element.
  This element contains only annotation type ref and simple argument
  mapping

FirAnnotationCall is a element for call of annotation (`@Ann(args)`)
  which was written in user code. FirAnnotationCall is a resolvable call

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotation.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.expressions
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -17,15 +16,13 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirAnnotation : FirExpression(), FirCall, FirResolvable {
+abstract class FirAnnotation : FirExpression() {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotation>
-    abstract override val argumentList: FirArgumentList
-    abstract override val calleeReference: FirReference
     abstract val useSiteTarget: AnnotationUseSiteTarget?
     abstract val annotationTypeRef: FirTypeRef
-    abstract val resolveStatus: FirAnnotationResolveStatus
+    abstract val argumentMapping: FirAnnotationArgumentMapping
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotation(this, data)
 
@@ -35,15 +32,9 @@ abstract class FirAnnotation : FirExpression(), FirCall, FirResolvable {
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
 
-    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+    abstract fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping)
-
-    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
-
-    abstract fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotation
 
-    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotation
-
     abstract fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirAnnotation
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationArgumentMapping.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.fir.expressions
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+abstract class FirAnnotationArgumentMapping : FirPureAbstractElement(), FirElement {
+    abstract override val source: FirSourceElement?
+    abstract val mapping: Map<Name, FirExpression>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationArgumentMapping(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+        transformer.transformAnnotationArgumentMapping(this, data) as E
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.fir.expressions
+
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.references.FirReference
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+abstract class FirAnnotationCall : FirAnnotation(), FirCall, FirResolvable {
+    abstract override val source: FirSourceElement?
+    abstract override val typeRef: FirTypeRef
+    abstract override val annotations: List<FirAnnotation>
+    abstract override val useSiteTarget: AnnotationUseSiteTarget?
+    abstract override val annotationTypeRef: FirTypeRef
+    abstract override val argumentList: FirArgumentList
+    abstract override val calleeReference: FirReference
+    abstract override val argumentMapping: FirAnnotationArgumentMapping
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationCall(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+        transformer.transformAnnotationCall(this, data) as E
+
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
+    abstract override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCall
+
+    abstract override fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirAnnotationCall
+
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotationCall
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationBuilder.kt

@@ -11,13 +11,9 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
-import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationImpl
-import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -27,24 +23,18 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 @FirBuilderDsl
-class FirAnnotationBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
+class FirAnnotationBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder {
     override var source: FirSourceElement? = null
-    override val annotations: MutableList<FirAnnotation> = mutableListOf()
-    override var argumentList: FirArgumentList = FirEmptyArgumentList
-    lateinit var calleeReference: FirReference
     var useSiteTarget: AnnotationUseSiteTarget? = null
     lateinit var annotationTypeRef: FirTypeRef
-    var resolveStatus: FirAnnotationResolveStatus = FirAnnotationResolveStatus.Unresolved
+    lateinit var argumentMapping: FirAnnotationArgumentMapping
 
     override fun build(): FirAnnotation {
         return FirAnnotationImpl(
             source,
-            annotations,
-            argumentList,
-            calleeReference,
             useSiteTarget,
             annotationTypeRef,
-            resolveStatus,
+            argumentMapping,
         )
     }
 
@@ -55,6 +45,9 @@ class FirAnnotationBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirE
         set(_) {
             throw IllegalStateException()
         }
+
+    @Deprecated("Modification of 'annotations' has no impact for FirAnnotationBuilder", level = DeprecationLevel.HIDDEN)
+    override val annotations: MutableList<FirAnnotation> = mutableListOf()
 }
 
 @OptIn(ExperimentalContracts::class)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationCallBuilder.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.fir.expressions.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirArgumentList
+import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
+import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
+import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
+import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationCallImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.references.FirReference
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirAnnotationCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder, FirExpressionBuilder {
+    override var source: FirSourceElement? = null
+    var useSiteTarget: AnnotationUseSiteTarget? = null
+    var annotationTypeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
+    override var argumentList: FirArgumentList = FirEmptyArgumentList
+    lateinit var calleeReference: FirReference
+    var argumentMapping: FirAnnotationArgumentMapping = FirEmptyAnnotationArgumentMapping
+
+    override fun build(): FirAnnotationCall {
+        return FirAnnotationCallImpl(
+            source,
+            useSiteTarget,
+            annotationTypeRef,
+            argumentList,
+            calleeReference,
+            argumentMapping,
+        )
+    }
+
+
+    @Deprecated("Modification of 'typeRef' has no impact for FirAnnotationCallBuilder", level = DeprecationLevel.HIDDEN)
+    override var typeRef: FirTypeRef
+        get() = throw IllegalStateException()
+        set(_) {
+            throw IllegalStateException()
+        }
+
+    @Deprecated("Modification of 'annotations' has no impact for FirAnnotationCallBuilder", level = DeprecationLevel.HIDDEN)
+    override val annotations: MutableList<FirAnnotation> = mutableListOf()
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildAnnotationCall(init: FirAnnotationCallBuilder.() -> Unit): FirAnnotationCall {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAnnotationCallBuilder().apply(init).build()
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt

@@ -0,0 +1,74 @@
+/*
+ * 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.fir.expressions.impl
+
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirArgumentList
+import org.jetbrains.kotlin.fir.references.FirReference
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+internal class FirAnnotationCallImpl(
+    override val source: FirSourceElement?,
+    override val useSiteTarget: AnnotationUseSiteTarget?,
+    override var annotationTypeRef: FirTypeRef,
+    override var argumentList: FirArgumentList,
+    override var calleeReference: FirReference,
+    override var argumentMapping: FirAnnotationArgumentMapping,
+) : FirAnnotationCall() {
+    override val typeRef: FirTypeRef get() = annotationTypeRef
+    override val annotations: List<FirAnnotation> get() = emptyList()
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        annotationTypeRef.accept(visitor, data)
+        argumentList.accept(visitor, data)
+        calleeReference.accept(visitor, data)
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        transformAnnotationTypeRef(transformer, data)
+        argumentList = argumentList.transform(transformer, data)
+        transformCalleeReference(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        return this
+    }
+
+    override fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        annotationTypeRef = annotationTypeRef.transform(transformer, data)
+        return this
+    }
+
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        calleeReference = calleeReference.transform(transformer, data)
+        return this
+    }
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
+    override fun replaceArgumentList(newArgumentList: FirArgumentList) {
+        argumentList = newArgumentList
+    }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
+    override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) {
+        argumentMapping = newArgumentMapping
+    }
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationImpl.kt

@@ -8,9 +8,7 @@ package org.jetbrains.kotlin.fir.expressions.impl
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -21,37 +19,25 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirAnnotationImpl(
     override val source: FirSourceElement?,
-    override val annotations: MutableList<FirAnnotation>,
-    override var argumentList: FirArgumentList,
-    override var calleeReference: FirReference,
     override val useSiteTarget: AnnotationUseSiteTarget?,
     override var annotationTypeRef: FirTypeRef,
-    override var resolveStatus: FirAnnotationResolveStatus,
+    override var argumentMapping: FirAnnotationArgumentMapping,
 ) : FirAnnotation() {
     override val typeRef: FirTypeRef get() = annotationTypeRef
+    override val annotations: List<FirAnnotation> get() = emptyList()
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        annotations.forEach { it.accept(visitor, data) }
-        argumentList.accept(visitor, data)
-        calleeReference.accept(visitor, data)
         annotationTypeRef.accept(visitor, data)
+        argumentMapping.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnnotationImpl {
-        transformAnnotations(transformer, data)
-        argumentList = argumentList.transform(transformer, data)
-        transformCalleeReference(transformer, data)
         transformAnnotationTypeRef(transformer, data)
+        argumentMapping = argumentMapping.transform(transformer, data)
         return this
     }
 
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationImpl {
-        annotations.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotationImpl {
-        calleeReference = calleeReference.transform(transformer, data)
         return this
     }
 
@@ -62,15 +48,7 @@ internal class FirAnnotationImpl(
 
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 
-    override fun replaceArgumentList(newArgumentList: FirArgumentList) {
+    override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) {
-        argumentList = newArgumentList
+        argumentMapping = newArgumentMapping
-    }
-
-    override fun replaceCalleeReference(newCalleeReference: FirReference) {
-        calleeReference = newCalleeReference
-    }
-
-    override fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus) {
-        resolveStatus = newResolveStatus
     }
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
 import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
@@ -405,6 +407,14 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformElement(annotation, data)
     }
 
+    open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement {
+        return transformElement(annotationCall, data)
+    }
+
+    open fun transformAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping {
+        return transformElement(annotationArgumentMapping, data)
+    }
+
     open fun transformComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement {
         return transformElement(comparisonExpression, data)
     }
@@ -925,6 +935,14 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformAnnotation(annotation, data)
     }
 
+    final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): FirStatement {
+        return transformAnnotationCall(annotationCall, data)
+    }
+
+    final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): FirAnnotationArgumentMapping {
+        return transformAnnotationArgumentMapping(annotationArgumentMapping, data)
+    }
+
     final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): FirStatement {
         return transformComparisonExpression(comparisonExpression, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
 import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
@@ -274,6 +276,10 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitAnnotation(annotation: FirAnnotation, data: D): R  = visitElement(annotation, data)
 
+    open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R  = visitElement(annotationCall, data)
+
+    open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: D): R  = visitElement(annotationArgumentMapping, data)
+
     open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: D): R  = visitElement(comparisonExpression, data)
 
     open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R  = visitElement(typeOperatorCall, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -71,6 +71,8 @@ import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
 import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
@@ -404,6 +406,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(annotation)
     }
 
+    open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
+        visitElement(annotationCall)
+    }
+
+    open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) {
+        visitElement(annotationArgumentMapping)
+    }
+
     open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) {
         visitElement(comparisonExpression)
     }
@@ -924,6 +934,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitAnnotation(annotation)
     }
 
+    final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) {
+        visitAnnotationCall(annotationCall)
+    }
+
+    final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: Nothing?) {
+        visitAnnotationArgumentMapping(annotationArgumentMapping)
+    }
+
     final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: Nothing?) {
         visitComparisonExpression(comparisonExpression)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirAnnotationArgumentMappingBuilder.kt

@@ -0,0 +1,50 @@
+/*
+ * 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.fir.expressions.builder
+
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.FirArgumentList
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationArgumentMappingImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
+import org.jetbrains.kotlin.name.Name
+import kotlin.annotations.jvm.UnderMigration
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@FirBuilderDsl
+class FirAnnotationArgumentMappingBuilder {
+    var source: FirSourceElement? = null
+    val mapping: MutableMap<Name, FirExpression> = mutableMapOf()
+
+    fun build(): FirAnnotationArgumentMapping {
+        if (source == null && mapping.isEmpty()) return FirEmptyAnnotationArgumentMapping
+        return FirAnnotationArgumentMappingImpl(source, mapping)
+    }
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildAnnotationArgumentMapping(init: FirAnnotationArgumentMappingBuilder.() -> Unit = {}): FirAnnotationArgumentMapping {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+    return FirAnnotationArgumentMappingBuilder().apply(init).build()
+}
+
+fun FirArgumentList.toAnnotationArgumentMapping(): FirAnnotationArgumentMapping {
+    return buildAnnotationArgumentMapping {
+        source = this@toAnnotationArgumentMapping.source
+        if (this@toAnnotationArgumentMapping is FirResolvedArgumentList) {
+            this@toAnnotationArgumentMapping.mapping
+                .map { (argument, parameter) -> parameter.name to argument }
+                .toMap(mapping)
+        }
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationArgumentMappingImpl.kt

@@ -0,0 +1,38 @@
+/*
+ * 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.fir.expressions.impl
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import org.jetbrains.kotlin.name.Name
+
+class FirAnnotationArgumentMappingImpl(
+    override val source: FirSourceElement?,
+    override val mapping: Map<Name, FirExpression>
+) : FirAnnotationArgumentMapping() {
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        return this
+    }
+}
+
+object FirEmptyAnnotationArgumentMapping : FirAnnotationArgumentMapping() {
+    override val source: FirSourceElement?
+        get() = null
+    override val mapping: Map<Name, FirExpression>
+        get() = emptyMap()
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        return this
+    }
+}

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -108,13 +108,14 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             withCopy()
         }
 
-        builder(annotation) {
+        builder(annotationCall) {
             parents += callBuilder
             default("argumentList") {
                 value = "FirEmptyArgumentList"
             }
-            default("resolveStatus", "FirAnnotationResolveStatus.Unresolved")
+            default("argumentMapping", "FirEmptyAnnotationArgumentMapping")
-            useTypes(emptyArgumentListType)
+            default("annotationTypeRef", "FirImplicitTypeRefImpl(null)")
+            useTypes(emptyArgumentListType, emptyAnnotationArgumentMappingType, implicitTypeRefType)
         }
 
         builder(arrayOfCall) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -89,7 +89,9 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val typeProjectionWithVariance by element(TypeRef, typeProjection)
     val argumentList by element(Expression)
     val call by sealedElement(Expression, statement) // TODO: may smth like `CallWithArguments` or `ElementWithArguments`?
-    val annotation by element(Expression, expression, call, resolvable)
+    val annotation by element(Expression, expression)
+    val annotationCall by element(Expression, annotation, call, resolvable)
+    val annotationArgumentMapping by element(Expression)
     val comparisonExpression by element(Expression, expression)
     val typeOperatorCall by element(Expression, expression, call)
     val assignmentOperatorStatement by element(Expression, statement)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -73,13 +73,25 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             delegateFields(listOf("aliasName", "importedFqName", "isAllUnder", "source"), "delegate")
         }
 
-        impl(annotation) {
+        fun ImplementationContext.commonAnnotationConfig(): Unit {
+            defaultEmptyList("annotations")
             default("typeRef") {
                 value = "annotationTypeRef"
                 withGetter = true
             }
         }
 
+        impl(annotation) {
+            commonAnnotationConfig()
+        }
+
+        impl(annotationCall) {
+            commonAnnotationConfig()
+            default("argumentMapping") {
+                needAcceptAndTransform = false
+            }
+        }
+
         impl(arrayOfCall)
 
         impl(callableReferenceAccess)
@@ -501,6 +513,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         }
 
         noImpl(argumentList)
+        noImpl(annotationArgumentMapping)
 
         val implementationsWithoutStatusAndTypeParameters = listOf(
             "FirAnonymousFunctionImpl",

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -447,7 +447,15 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         annotation.configure {
             +field("useSiteTarget", annotationUseSiteTargetType, nullable = true)
             +field("annotationTypeRef", typeRef).withTransform()
-            +field("resolveStatus", annotationResolveStatusType, withReplace = true)
+            +field("argumentMapping", annotationArgumentMapping, withReplace = true)
+        }
+
+        annotationCall.configure {
+            +field("argumentMapping", annotationArgumentMapping, withReplace = true)
+        }
+
+        annotationArgumentMapping.configure {
+            +field("mapping", type("Map") to listOf(nameType, expression))
         }
 
         augmentedArraySetCall.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -83,7 +83,6 @@ val dslBuilderAnnotationType = generatedType("builder", "FirBuilderDsl")
 val firImplementationDetailType = generatedType("FirImplementationDetail")
 val declarationOriginType = generatedType("declarations", "FirDeclarationOrigin")
 val declarationAttributesType = generatedType("declarations", "FirDeclarationAttributes")
-val annotationResolveStatusType = generatedType("expressions", "FirAnnotationResolveStatus")
 
 val exhaustivenessStatusType = generatedType("expressions", "ExhaustivenessStatus")
 
@@ -94,6 +93,7 @@ val functionCallOrigin = type("fir.expressions", "FirFunctionCallOrigin")
 val resolvedDeclarationStatusImplType = type("fir.declarations.impl", "FirResolvedDeclarationStatusImpl")
 
 val deprecationsPerUseSiteType = type("fir.declarations", "DeprecationsPerUseSite")
+val emptyAnnotationArgumentMappingType = type("fir.expressions.impl", "FirEmptyAnnotationArgumentMapping")
 
 val firPropertySymbolType = type("fir.symbols.impl", "FirPropertySymbol")