[FIR] Add transformAnnotations for fir nodes

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -76,11 +76,11 @@ class FirJavaClass @FirImplementationDetail internal constructor(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirJavaClass {
-        declarations.transformInplace(transformer, data)
-        annotations.transformInplace(transformer, data)
         typeParameters.transformInplace(transformer, data)
+        declarations.transformInplace(transformer, data)
         status = status.transformSingle(transformer, data)
         superTypeRefs.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 
@@ -92,6 +92,11 @@ class FirJavaClass @FirImplementationDetail internal constructor(
     override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirRegularClass {
         return this
     }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJavaClass {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
 }
 
 @FirBuilderDsl

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaConstructor.kt

@@ -86,7 +86,7 @@ class FirJavaConstructor @FirImplementationDetail constructor(
         typeParameters.transformInplace(transformer, data)
         transformValueParameters(transformer, data)
         status = status.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 
@@ -99,6 +99,11 @@ class FirJavaConstructor @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJavaConstructor {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override var containerSource: DeserializedContainerSource? = null
 
     override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef) {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt

@@ -67,7 +67,7 @@ class FirJavaField @FirImplementationDetail constructor(
     }
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirField {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         return this
     }
@@ -101,6 +101,11 @@ class FirJavaField @FirImplementationDetail constructor(
         returnTypeRef = newReturnTypeRef
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJavaField {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override val delegate: FirExpression?
         get() = null
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerLiteralTypeScope.kt

@@ -149,5 +149,9 @@ class FirILTTypeRefPlaceHolder(isUnsigned: Boolean) : FirResolvedTypeRef() {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         return this
     }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirResolvedTypeRef {
+        return this
+    }
 }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/FirAnnotationContainer.kt

@@ -18,4 +18,6 @@ interface FirAnnotationContainer : FirElement {
     val annotations: List<FirAnnotationCall>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationContainer(this, data)
+
+    fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationContainer
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -43,6 +43,8 @@ abstract class FirAnonymousFunction : FirFunction<FirAnonymousFunction>, FirExpr
 
     abstract fun replaceInvocationKind(newInvocationKind: InvocationKind?)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirAnonymousFunction
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirAnonymousFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt

@@ -36,5 +36,7 @@ abstract class FirAnonymousObject : FirClass<FirAnonymousObject>, FirExpression(
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousObject(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousObject
+
     abstract fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirAnonymousObject
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableDeclaration.kt

@@ -31,6 +31,8 @@ interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirTypedDeclar
 
     fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>
+
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>
 
     fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirCallableMemberDeclaration.kt

@@ -32,6 +32,8 @@ interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : Fi
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableMemberDeclaration(this, data)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
+
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
 
     override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClass.kt

@@ -35,4 +35,6 @@ interface FirClass<F : FirClass<F>> : FirClassLikeDeclaration<F>, FirStatement,
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
 
     fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClass<F>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirClassLikeDeclaration.kt

@@ -26,4 +26,6 @@ interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirDeclarati
     override val symbol: FirClassLikeSymbol<F>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassLikeDeclaration(this, data)
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassLikeDeclaration<F>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt

@@ -50,4 +50,6 @@ abstract class FirConstructor : FirPureAbstractElement(), FirFunction<FirConstru
     abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirConstructor
 
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirConstructor
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstructor
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -55,6 +55,8 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
 
     abstract override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirEnumEntry
+
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirEnumEntry

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt

@@ -38,6 +38,8 @@ abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirError
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorFunction(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorFunction
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorFunction
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirErrorFunction

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirField.kt

@@ -55,6 +55,8 @@ abstract class FirField : FirVariable<FirField>(), FirCallableMemberDeclaration<
 
     abstract override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirField
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirField
+
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirField
 
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirField

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFile.kt

@@ -29,4 +29,6 @@ abstract class FirFile : FirPureAbstractElement(), FirAnnotationContainer, FirDe
     abstract val packageFqName: FqName
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFile(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFile
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirFunction.kt

@@ -39,6 +39,8 @@ interface FirFunction<F : FirFunction<F>> : FirCallableDeclaration<F>, FirTarget
 
     fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunction<F>
+
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<F>
 
     override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirFunction<F>

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt

@@ -26,5 +26,7 @@ interface FirMemberDeclaration : FirDeclaration, FirAnnotationContainer {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitMemberDeclaration(this, data)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirMemberDeclaration
+
     fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirMemberDeclaration
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirProperty.kt

@@ -60,6 +60,8 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
 
     abstract override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirProperty
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirProperty
+
     abstract fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirProperty
 
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirProperty

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt

@@ -51,4 +51,6 @@ abstract class FirPropertyAccessor : FirPureAbstractElement(), FirFunction<FirPr
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
     abstract fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -43,6 +43,8 @@ abstract class FirRegularClass : FirPureAbstractElement(), FirMemberDeclaration,
 
     abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirRegularClass
+
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirRegularClass
 
     abstract fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirRegularClass

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSealedClass.kt

@@ -44,6 +44,8 @@ abstract class FirSealedClass : FirRegularClass() {
 
     abstract fun replaceInheritors(newInheritors: List<ClassId>)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSealedClass
+
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSealedClass
 
     abstract override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirSealedClass

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirSimpleFunction.kt

@@ -53,4 +53,6 @@ abstract class FirSimpleFunction : FirPureAbstractElement(), FirFunction<FirSimp
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
     abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirSimpleFunction
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt

@@ -35,4 +35,6 @@ abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<
     abstract fun replaceExpandedTypeRef(newExpandedTypeRef: FirTypeRef)
 
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirTypeAlias
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeAlias
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt

@@ -34,4 +34,6 @@ abstract class FirTypeParameter : FirPureAbstractElement(), FirDeclaration, FirS
     abstract override val annotations: List<FirAnnotationCall>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeParameter
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt

@@ -28,5 +28,7 @@ interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer {
 
     fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration
+
     fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirTypedDeclaration
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt

@@ -55,5 +55,7 @@ abstract class FirValueParameter : FirVariable<FirValueParameter>() {
 
     abstract override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirValueParameter
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirValueParameter
+
     abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirValueParameter
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirVariable.kt

@@ -53,5 +53,7 @@ abstract class FirVariable<F : FirVariable<F>> : FirPureAbstractElement(), FirCa
 
     abstract fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirVariable<F>
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariable<F>
+
     abstract fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirVariable<F>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -60,7 +60,7 @@ internal class FirAnonymousFunctionImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnonymousFunctionImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         transformReturnTypeRef(transformer, data)
         transformReceiverTypeRef(transformer, data)
         typeParameters.transformInplace(transformer, data)
@@ -72,6 +72,11 @@ internal class FirAnonymousFunctionImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousFunctionImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirAnonymousFunctionImpl {
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -53,12 +53,17 @@ internal class FirAnonymousObjectImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnonymousObjectImpl {
         superTypeRefs.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeRef = typeRef.transformSingle(transformer, data)
         transformControlFlowGraphReference(transformer, data)
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousObjectImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirAnonymousObjectImpl {
         controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -60,7 +60,7 @@ internal class FirClassImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirClassImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         transformStatus(transformer, data)
         (declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)
@@ -71,6 +71,11 @@ internal class FirClassImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirClassImpl {
         status = status.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt

@@ -66,7 +66,7 @@ internal class FirConstructorImpl(
         transformControlFlowGraphReference(transformer, data)
         transformValueParameters(transformer, data)
         transformStatus(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         delegatedConstructor = delegatedConstructor?.transformSingle(transformer, data)
         body = body?.transformSingle(transformer, data)
         return this
@@ -97,6 +97,11 @@ internal class FirConstructorImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstructorImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt

@@ -102,8 +102,13 @@ internal class FirDefaultSetterValueParameter(
         return this
     }
 
-    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirDefaultSetterValueParameter {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirDefaultSetterValueParameter {
         annotations.transformInplace(transformer, data)
+        return this
+    }
+
+    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirDefaultSetterValueParameter {
+        transformAnnotations(transformer, data)
         defaultValue = defaultValue?.transformSingle(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt

@@ -94,13 +94,18 @@ internal class FirEnumEntryImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirEnumEntryImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirEnumEntryImpl {
         status = status.transformSingle(transformer, data)
         return this
     }
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirEnumEntryImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt

@@ -54,7 +54,7 @@ internal class FirErrorFunctionImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirErrorFunctionImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         transformReturnTypeRef(transformer, data)
         typeParameters.transformInplace(transformer, data)
         transformControlFlowGraphReference(transformer, data)
@@ -62,6 +62,11 @@ internal class FirErrorFunctionImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorFunctionImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorFunctionImpl {
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFieldImpl.kt

@@ -91,13 +91,18 @@ internal class FirFieldImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFieldImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirFieldImpl {
         status = status.transformSingle(transformer, data)
         return this
     }
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirFieldImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt

@@ -37,12 +37,17 @@ internal class FirFileImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirFileImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         imports.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFileImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructor.kt

@@ -66,7 +66,7 @@ internal class FirPrimaryConstructor(
         transformControlFlowGraphReference(transformer, data)
         transformValueParameters(transformer, data)
         transformStatus(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         delegatedConstructor = delegatedConstructor?.transformSingle(transformer, data)
         body = body?.transformSingle(transformer, data)
         return this
@@ -97,6 +97,11 @@ internal class FirPrimaryConstructor(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirPrimaryConstructor {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt

@@ -70,7 +70,7 @@ open class FirPropertyAccessorImpl @FirImplementationDetail constructor(
         body = body?.transformSingle(transformer, data)
         transformContractDescription(transformer, data)
         transformStatus(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 
@@ -103,6 +103,11 @@ open class FirPropertyAccessorImpl @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirPropertyAccessorImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyImpl.kt

@@ -115,6 +115,11 @@ internal class FirPropertyImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirPropertyImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirPropertyImpl {
         controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
         return this
@@ -126,7 +131,7 @@ internal class FirPropertyImpl(
     }
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirPropertyImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirSealedClassImpl.kt

@@ -63,7 +63,7 @@ internal class FirSealedClassImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeParameters.transformInplace(transformer, data)
         transformStatus(transformer, data)
         (declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)
@@ -74,6 +74,11 @@ internal class FirSealedClassImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirSealedClassImpl {
         status = status.transformSingle(transformer, data)
         return this

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirSimpleFunctionImpl.kt

@@ -73,7 +73,7 @@ open class FirSimpleFunctionImpl @FirImplementationDetail constructor(
         body = body?.transformSingle(transformer, data)
         transformStatus(transformer, data)
         transformContractDescription(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 
@@ -107,6 +107,11 @@ open class FirSimpleFunctionImpl @FirImplementationDetail constructor(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSimpleFunctionImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt

@@ -48,7 +48,7 @@ internal class FirTypeAliasImpl(
         typeParameters.transformInplace(transformer, data)
         transformStatus(transformer, data)
         expandedTypeRef = expandedTypeRef.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 
@@ -57,6 +57,11 @@ internal class FirTypeAliasImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeAliasImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
         resolvePhase = newResolvePhase
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt

@@ -43,6 +43,11 @@ internal class FirTypeParameterImpl(
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirTypeParameterImpl {
         bounds.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeParameterImpl {
         annotations.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt

@@ -88,8 +88,13 @@ open class FirValueParameterImpl @FirImplementationDetail constructor(
         return this
     }
 
-    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirValueParameterImpl {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirValueParameterImpl {
         annotations.transformInplace(transformer, data)
+        return this
+    }
+
+    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirValueParameterImpl {
+        transformAnnotations(transformer, data)
         defaultValue = defaultValue?.transformSingle(transformer, data)
         return this
     }

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

@@ -24,4 +24,6 @@ abstract class FirAnnotationCall : FirExpression(), FirCall {
     abstract val annotationTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCall
 }

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

@@ -21,4 +21,6 @@ abstract class FirArrayOfCall : FirExpression(), FirCall {
     abstract override val argumentList: FirArgumentList
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitArrayOfCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirArrayOfCall
 }

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

@@ -26,4 +26,6 @@ abstract class FirAugmentedArraySetCall : FirPureAbstractElement(), FirStatement
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAugmentedArraySetCall(this, data)
 
     abstract fun replaceCalleeReference(newCalleeReference: FirReference)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAugmentedArraySetCall
 }

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

@@ -24,6 +24,8 @@ abstract class FirBinaryLogicExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBinaryLogicExpression(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpression
+
     abstract fun <D> transformLeftOperand(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpression
 
     abstract fun <D> transformRightOperand(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpression

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

@@ -24,6 +24,8 @@ abstract class FirBlock : FirExpression() {
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBlock
+
     abstract fun <D> transformStatements(transformer: FirTransformer<D>, data: D): FirBlock
 
     abstract fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirBlock

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

@@ -22,4 +22,6 @@ abstract class FirBreakExpression : FirLoopJump() {
     abstract override val target: FirTarget<FirLoop>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBreakExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBreakExpression
 }

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

@@ -21,4 +21,6 @@ interface FirCall : FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCall(this, data)
 
     fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCall
 }

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

@@ -29,6 +29,8 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableReferenceAccess(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess

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

@@ -24,5 +24,7 @@ abstract class FirCheckNotNullCall : FirExpression(), FirCall, FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCheckNotNullCall(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCheckNotNullCall
+
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirCheckNotNullCall
 }

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

@@ -21,4 +21,6 @@ abstract class FirClassReferenceExpression : FirExpression() {
     abstract val classTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassReferenceExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassReferenceExpression
 }

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

@@ -22,4 +22,6 @@ abstract class FirComparisonExpression : FirExpression() {
     abstract val compareToCall: FirFunctionCall
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComparisonExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirComparisonExpression
 }

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

@@ -31,6 +31,8 @@ abstract class FirComponentCall : FirFunctionCall() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComponentCall(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirComponentCall
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirComponentCall
 
     abstract override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirComponentCall

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

@@ -24,4 +24,6 @@ abstract class FirConstExpression<T> : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstExpression(this, data)
 
     abstract fun replaceKind(newKind: FirConstKind<T>)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstExpression<T>
 }

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

@@ -22,4 +22,6 @@ abstract class FirContinueExpression : FirLoopJump() {
     abstract override val target: FirTarget<FirLoop>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContinueExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirContinueExpression
 }

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

@@ -28,4 +28,6 @@ abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolv
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDelegatedConstructorCall(this, data)
 
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall
 }

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

@@ -23,6 +23,8 @@ abstract class FirDoWhileLoop : FirLoop() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDoWhileLoop(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirDoWhileLoop
+
     abstract override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirDoWhileLoop
 
     abstract override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirDoWhileLoop

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

@@ -23,4 +23,6 @@ abstract class FirErrorExpression : FirExpression(), FirDiagnosticHolder {
     abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorExpression
 }

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

@@ -26,6 +26,8 @@ abstract class FirErrorLoop : FirLoop(), FirDiagnosticHolder {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorLoop(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorLoop
+
     abstract override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirErrorLoop
 
     abstract override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirErrorLoop

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

@@ -23,4 +23,6 @@ abstract class FirExpression : FirPureAbstractElement(), FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitExpression(this, data)
 
     abstract fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirExpression
 }

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

@@ -33,6 +33,8 @@ abstract class FirExpressionWithSmartcast : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitExpressionWithSmartcast(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast

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

@@ -30,6 +30,8 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunctionCall(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunctionCall
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirFunctionCall
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirFunctionCall

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

@@ -22,4 +22,6 @@ abstract class FirGetClassCall : FirExpression(), FirCall {
     abstract val argument: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitGetClassCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirGetClassCall
 }

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

@@ -23,4 +23,6 @@ abstract class FirJump<E : FirTargetElement> : FirExpression() {
     abstract val target: FirTarget<E>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitJump(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJump<E>
 }

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

@@ -22,4 +22,6 @@ abstract class FirLambdaArgumentExpression : FirWrappedArgumentExpression() {
     abstract override val isSpread: Boolean
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLambdaArgumentExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLambdaArgumentExpression
 }

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

@@ -26,6 +26,8 @@ abstract class FirLoop : FirPureAbstractElement(), FirStatement, FirTargetElemen
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLoop(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLoop
+
     abstract fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirLoop
 
     abstract fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirLoop

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

@@ -22,4 +22,6 @@ abstract class FirLoopJump : FirJump<FirLoop>() {
     abstract override val target: FirTarget<FirLoop>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLoopJump(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLoopJump
 }

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

@@ -24,4 +24,6 @@ abstract class FirNamedArgumentExpression : FirWrappedArgumentExpression() {
     abstract val name: Name
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitNamedArgumentExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirNamedArgumentExpression
 }

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

@@ -22,4 +22,6 @@ abstract class FirOperatorCall : FirExpression(), FirCall {
     abstract val operation: FirOperation
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitOperatorCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirOperatorCall
 }

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

@@ -27,6 +27,8 @@ interface FirQualifiedAccess : FirQualifiedAccessWithoutCallee, FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccess(this, data)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+
     override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
     override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess

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

@@ -29,6 +29,8 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirQualifiedAcces
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccessExpression(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression

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

@@ -27,6 +27,8 @@ interface FirQualifiedAccessWithoutCallee : FirStatement {
 
     fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
+
     fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
 
     fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee

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

@@ -35,5 +35,7 @@ abstract class FirResolvedQualifier : FirExpression() {
 
     abstract fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirResolvedQualifier
+
     abstract fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirResolvedQualifier
 }

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

@@ -22,4 +22,6 @@ abstract class FirResolvedReifiedParameterReference : FirExpression() {
     abstract val symbol: FirTypeParameterSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedReifiedParameterReference(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirResolvedReifiedParameterReference
 }

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

@@ -25,6 +25,8 @@ abstract class FirReturnExpression : FirJump<FirFunction<*>>() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitReturnExpression(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirReturnExpression
+
     abstract fun <D> transformResult(transformer: FirTransformer<D>, data: D): FirReturnExpression
 
     abstract fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirReturnExpression

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

@@ -22,4 +22,6 @@ abstract class FirSpreadArgumentExpression : FirWrappedArgumentExpression() {
     abstract override val isSpread: Boolean
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSpreadArgumentExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSpreadArgumentExpression
 }

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

@@ -19,4 +19,6 @@ interface FirStatement : FirAnnotationContainer {
     override val annotations: List<FirAnnotationCall>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitStatement(this, data)
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirStatement
 }

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

@@ -21,4 +21,6 @@ abstract class FirStringConcatenationCall : FirCall, FirExpression() {
     abstract override val typeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitStringConcatenationCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirStringConcatenationCall
 }

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

@@ -29,6 +29,8 @@ abstract class FirThisReceiverExpression : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitThisReceiverExpression(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirThisReceiverExpression
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirThisReceiverExpression
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirThisReceiverExpression

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

@@ -21,4 +21,6 @@ abstract class FirThrowExpression : FirExpression() {
     abstract val exception: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitThrowExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirThrowExpression
 }

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

@@ -26,6 +26,8 @@ abstract class FirTryExpression : FirExpression(), FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTryExpression(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTryExpression
+
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirTryExpression
 
     abstract fun <D> transformTryBlock(transformer: FirTransformer<D>, data: D): FirTryExpression

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

@@ -23,4 +23,6 @@ abstract class FirTypeOperatorCall : FirExpression(), FirCall {
     abstract val conversionTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeOperatorCall(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeOperatorCall
 }

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

@@ -22,4 +22,6 @@ abstract class FirVarargArgumentsExpression : FirExpression() {
     abstract val varargElementType: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVarargArgumentsExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVarargArgumentsExpression
 }

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

@@ -30,6 +30,8 @@ abstract class FirVariableAssignment : FirPureAbstractElement(), FirQualifiedAcc
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVariableAssignment(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariableAssignment
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirVariableAssignment

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

@@ -30,6 +30,8 @@ abstract class FirWhenExpression : FirExpression(), FirResolvable {
 
     abstract fun replaceIsExhaustive(newIsExhaustive: Boolean)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWhenExpression
+
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirWhenExpression
 
     abstract fun <D> transformSubject(transformer: FirTransformer<D>, data: D): FirWhenExpression

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

@@ -22,4 +22,6 @@ abstract class FirWhenSubjectExpression : FirExpression() {
     abstract val whenSubject: FirWhenSubject
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWhenSubjectExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWhenSubjectExpression
 }

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

@@ -23,6 +23,8 @@ abstract class FirWhileLoop : FirLoop() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWhileLoop(this, data)
 
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWhileLoop
+
     abstract override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirWhileLoop
 
     abstract override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirWhileLoop

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

@@ -22,4 +22,6 @@ abstract class FirWrappedArgumentExpression : FirWrappedExpression() {
     abstract val isSpread: Boolean
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedArgumentExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedArgumentExpression
 }

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

@@ -22,4 +22,6 @@ abstract class FirWrappedDelegateExpression : FirWrappedExpression() {
     abstract val delegateProvider: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedDelegateExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedDelegateExpression
 }

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

@@ -21,4 +21,6 @@ abstract class FirWrappedExpression : FirExpression() {
     abstract val expression: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedExpression(this, data)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedExpression
 }

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

@@ -33,12 +33,17 @@ internal class FirAnnotationCallImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         argumentList = argumentList.transformSingle(transformer, data)
         annotationTypeRef = annotationTypeRef.transformSingle(transformer, data)
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCallImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {

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

@@ -33,11 +33,16 @@ internal class FirArrayOfCallImpl(
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirArrayOfCallImpl {
         typeRef = typeRef.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         argumentList = argumentList.transformSingle(transformer, data)
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirArrayOfCallImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
         typeRef = newTypeRef
     }

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

@@ -35,13 +35,18 @@ internal class FirAugmentedArraySetCallImpl(
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAugmentedArraySetCallImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         assignCall = assignCall.transformSingle(transformer, data)
         setGetBlock = setGetBlock.transformSingle(transformer, data)
         calleeReference = calleeReference.transformSingle(transformer, data)
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAugmentedArraySetCallImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun replaceCalleeReference(newCalleeReference: FirReference) {
         calleeReference = newCalleeReference
     }

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

@@ -42,6 +42,11 @@ internal class FirBinaryLogicExpressionImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpressionImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformLeftOperand(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpressionImpl {
         leftOperand = leftOperand.transformSingle(transformer, data)
         return this
@@ -54,7 +59,7 @@ internal class FirBinaryLogicExpressionImpl(
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpressionImpl {
         typeRef = typeRef.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         return this
     }
 

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

@@ -37,13 +37,18 @@ internal class FirBlockImpl(
         return this
     }
 
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBlockImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
     override fun <D> transformStatements(transformer: FirTransformer<D>, data: D): FirBlockImpl {
         statements.transformInplace(transformer, data)
         return this
     }
 
     override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirBlockImpl {
-        annotations.transformInplace(transformer, data)
+        transformAnnotations(transformer, data)
         typeRef = typeRef.transformSingle(transformer, data)
         return this
     }

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

@@ -33,6 +33,11 @@ internal class FirBreakExpressionImpl(
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirBreakExpressionImpl {
         typeRef = typeRef.transformSingle(transformer, data)
+        transformAnnotations(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBreakExpressionImpl {
         annotations.transformInplace(transformer, data)
         return this
     }