[FIR] Make FirAnnotationCall resolvable

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 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.*
 
@@ -15,11 +16,12 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirAnnotationCall : FirExpression(), FirCall {
+abstract class FirAnnotationCall : FirExpression(), FirCall, FirResolvable {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val argumentList: FirArgumentList
+    abstract override val calleeReference: FirReference
     abstract val useSiteTarget: AnnotationUseSiteTarget?
     abstract val annotationTypeRef: FirTypeRef
     abstract val resolveStatus: FirAnnotationResolveStatus
@@ -30,9 +32,13 @@ abstract class FirAnnotationCall : FirExpression(), FirCall {
 
     abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
 
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCall
 
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotationCall
+
     abstract fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirAnnotationCall
 }

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

@@ -17,6 +17,7 @@ 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.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -30,6 +31,7 @@ class FirAnnotationCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder,
     override var source: FirSourceElement? = null
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override var argumentList: FirArgumentList = FirEmptyArgumentList
+    lateinit var calleeReference: FirReference
     var useSiteTarget: AnnotationUseSiteTarget? = null
     lateinit var annotationTypeRef: FirTypeRef
     var resolveStatus: FirAnnotationResolveStatus = FirAnnotationResolveStatus.Unresolved
@@ -39,6 +41,7 @@ class FirAnnotationCallBuilder : FirCallBuilder, FirAnnotationContainerBuilder,
             source,
             annotations,
             argumentList,
+            calleeReference,
             useSiteTarget,
             annotationTypeRef,
             resolveStatus,

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationResolveStatus
 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.*
 
@@ -22,6 +23,7 @@ internal class FirAnnotationCallImpl(
     override val source: FirSourceElement?,
     override val annotations: MutableList<FirAnnotationCall>,
     override var argumentList: FirArgumentList,
+    override var calleeReference: FirReference,
     override val useSiteTarget: AnnotationUseSiteTarget?,
     override var annotationTypeRef: FirTypeRef,
     override var resolveStatus: FirAnnotationResolveStatus,
@@ -31,12 +33,14 @@ internal class FirAnnotationCallImpl(
     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)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
         transformAnnotations(transformer, data)
         argumentList = argumentList.transformSingle(transformer, data)
+        transformCalleeReference(transformer, data)
         transformAnnotationTypeRef(transformer, data)
         return this
     }
@@ -46,6 +50,11 @@ internal class FirAnnotationCallImpl(
         return this
     }
 
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        return this
+    }
+
     override fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
         annotationTypeRef = annotationTypeRef.transformSingle(transformer, data)
         return this
@@ -57,6 +66,10 @@ internal class FirAnnotationCallImpl(
         argumentList = newArgumentList
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
     override fun replaceResolveStatus(newResolveStatus: FirAnnotationResolveStatus) {
         resolveStatus = newResolveStatus
     }

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

@@ -83,7 +83,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val typeProjectionWithVariance = element("TypeProjectionWithVariance", TypeRef, typeProjection)
     val argumentList = element("ArgumentList", Expression)
     val call = element("Call", Expression, statement) // TODO: may smth like `CallWithArguments` or `ElementWithArguments`?
-    val annotationCall = element("AnnotationCall", Expression, expression, call)
+    val annotationCall = element("AnnotationCall", Expression, expression, call, resolvable)
     val comparisonExpression = element("ComparisonExpression", Expression, expression)
     val typeOperatorCall = element("TypeOperatorCall", Expression, expression, call)
     val assignmentOperatorStatement = element("AssignmentOperatorStatement", Expression, statement)