Fix minor formatting issue in generated FIR tree

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

@@ -21,7 +21,7 @@ interface FirAnnotationContainer : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationContainer(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnnotationContainer(this, data) as E
 
     fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationContainer

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

@@ -19,7 +19,7 @@ interface FirElement {
     fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElement(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformElement(this, data) as E
 
     fun accept(visitor: FirVisitorVoid) = accept(visitor, null)

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

@@ -22,7 +22,7 @@ abstract class FirElementWithResolvePhase : FirPureAbstractElement(), FirElement
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElementWithResolvePhase(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformElementWithResolvePhase(this, data) as E
 
     abstract fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -26,7 +26,7 @@ abstract class FirFileAnnotationsContainer : FirElementWithResolvePhase(), FirAn
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFileAnnotationsContainer(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformFileAnnotationsContainer(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -23,6 +23,6 @@ abstract class FirFunctionTypeParameter : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunctionTypeParameter(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformFunctionTypeParameter(this, data) as E
 }

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

@@ -20,6 +20,6 @@ abstract class FirLabel : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLabel(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformLabel(this, data) as E
 }

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

@@ -21,6 +21,6 @@ abstract class FirPackageDirective : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPackageDirective(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformPackageDirective(this, data) as E
 }

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

@@ -19,6 +19,6 @@ interface FirTargetElement : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTargetElement(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTargetElement(this, data) as E
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/FirContractDescription.kt

@@ -21,6 +21,6 @@ abstract class FirContractDescription : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContractDescription(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformContractDescription(this, data) as E
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/FirEffectDeclaration.kt

@@ -23,6 +23,6 @@ abstract class FirEffectDeclaration : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEffectDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformEffectDeclaration(this, data) as E
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/FirLegacyRawContractDescription.kt

@@ -22,6 +22,6 @@ abstract class FirLegacyRawContractDescription : FirContractDescription() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLegacyRawContractDescription(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformLegacyRawContractDescription(this, data) as E
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/FirRawContractDescription.kt

@@ -22,6 +22,6 @@ abstract class FirRawContractDescription : FirContractDescription() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitRawContractDescription(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformRawContractDescription(this, data) as E
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/contracts/FirResolvedContractDescription.kt

@@ -23,6 +23,6 @@ abstract class FirResolvedContractDescription : FirContractDescription() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedContractDescription(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvedContractDescription(this, data) as E
 }

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

@@ -53,7 +53,7 @@ abstract class FirAnonymousFunction : FirFunction(), FirTypeParametersOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousFunction(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnonymousFunction(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -35,7 +35,7 @@ abstract class FirAnonymousInitializer : FirDeclaration(), FirControlFlowGraphOw
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousInitializer(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnonymousInitializer(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -41,7 +41,7 @@ abstract class FirAnonymousObject : FirClass(), FirControlFlowGraphOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousObject(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnonymousObject(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -53,7 +53,7 @@ abstract class FirBackingField : FirVariable(), FirTypeParametersOwner, FirState
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBackingField(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformBackingField(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -40,7 +40,7 @@ sealed class FirCallableDeclaration : FirMemberDeclaration() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCallableDeclaration(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -40,7 +40,7 @@ sealed class FirClass : FirClassLikeDeclaration(), FirStatement, FirTypeParamete
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformClass(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -33,7 +33,7 @@ sealed class FirClassLikeDeclaration : FirMemberDeclaration(), FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassLikeDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformClassLikeDeclaration(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -48,7 +48,7 @@ abstract class FirConstructor : FirFunction(), FirTypeParameterRefsOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstructor(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformConstructor(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -26,7 +26,7 @@ abstract class FirContextReceiver : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContextReceiver(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformContextReceiver(this, data) as E
 
     abstract fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -22,7 +22,7 @@ sealed interface FirContractDescriptionOwner : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContractDescriptionOwner(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformContractDescriptionOwner(this, data) as E
 
     fun replaceContractDescription(newContractDescription: FirContractDescription)

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

@@ -22,7 +22,7 @@ interface FirControlFlowGraphOwner : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitControlFlowGraphOwner(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformControlFlowGraphOwner(this, data) as E
 
     fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?)

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

@@ -31,7 +31,7 @@ sealed class FirDeclaration : FirElementWithResolvePhase(), FirAnnotationContain
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformDeclaration(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -42,6 +42,6 @@ interface FirDeclarationStatus : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDeclarationStatus(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformDeclarationStatus(this, data) as E
 }

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

@@ -50,7 +50,7 @@ abstract class FirEnumEntry : FirVariable() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEnumEntry(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformEnumEntry(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -48,7 +48,7 @@ abstract class FirErrorFunction : FirFunction(), FirDiagnosticHolder {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorFunction(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorFunction(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -31,6 +31,6 @@ abstract class FirErrorImport : FirPureAbstractElement(), FirImport, FirDiagnost
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorImport(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorImport(this, data) as E
 }

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

@@ -53,7 +53,7 @@ abstract class FirErrorProperty : FirVariable(), FirDiagnosticHolder {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorProperty(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorProperty(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -52,7 +52,7 @@ abstract class FirField : FirVariable(), FirControlFlowGraphOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitField(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformField(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -40,7 +40,7 @@ abstract class FirFile : FirDeclaration() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFile(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformFile(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -47,7 +47,7 @@ sealed class FirFunction : FirCallableDeclaration(), FirTargetElement, FirContro
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunction(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformFunction(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -26,6 +26,6 @@ interface FirImport : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitImport(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformImport(this, data) as E
 }

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

@@ -31,7 +31,7 @@ sealed class FirMemberDeclaration : FirDeclaration(), FirTypeParameterRefsOwner
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitMemberDeclaration(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformMemberDeclaration(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -56,7 +56,7 @@ abstract class FirProperty : FirVariable(), FirTypeParametersOwner, FirControlFl
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitProperty(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformProperty(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -51,7 +51,7 @@ abstract class FirPropertyAccessor : FirFunction(), FirContractDescriptionOwner,
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPropertyAccessor(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformPropertyAccessor(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -26,7 +26,7 @@ abstract class FirReceiverParameter : FirPureAbstractElement(), FirAnnotationCon
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitReceiverParameter(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformReceiverParameter(this, data) as E
 
     abstract fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -46,7 +46,7 @@ abstract class FirRegularClass : FirClass(), FirControlFlowGraphOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitRegularClass(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformRegularClass(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -44,6 +44,6 @@ interface FirResolvedDeclarationStatus : FirDeclarationStatus {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedDeclarationStatus(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvedDeclarationStatus(this, data) as E
 }

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

@@ -33,6 +33,6 @@ abstract class FirResolvedImport : FirPureAbstractElement(), FirImport {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedImport(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvedImport(this, data) as E
 }

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

@@ -34,7 +34,7 @@ abstract class FirScript : FirDeclaration() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitScript(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformScript(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -49,7 +49,7 @@ abstract class FirSimpleFunction : FirFunction(), FirContractDescriptionOwner, F
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSimpleFunction(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformSimpleFunction(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -36,7 +36,7 @@ abstract class FirTypeAlias : FirClassLikeDeclaration(), FirTypeParametersOwner
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeAlias(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTypeAlias(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -38,7 +38,7 @@ abstract class FirTypeParameter : FirTypeParameterRef, FirDeclaration() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTypeParameter(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -22,6 +22,6 @@ interface FirTypeParameterRef : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameterRef(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTypeParameterRef(this, data) as E
 }

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

@@ -21,7 +21,7 @@ sealed interface FirTypeParameterRefsOwner : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameterRefsOwner(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTypeParameterRefsOwner(this, data) as E
 
     fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirTypeParameterRefsOwner

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

@@ -21,7 +21,7 @@ sealed interface FirTypeParametersOwner : FirTypeParameterRefsOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParametersOwner(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformTypeParametersOwner(this, data) as E
 
     override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirTypeParametersOwner

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

@@ -58,7 +58,7 @@ abstract class FirValueParameter : FirVariable(), FirControlFlowGraphOwner {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitValueParameter(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformValueParameter(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

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

@@ -51,7 +51,7 @@ sealed class FirVariable : FirCallableDeclaration(), FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVariable(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformVariable(this, data) as E
 
     abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt

@@ -21,6 +21,6 @@ interface FirDiagnosticHolder : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDiagnosticHolder(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformDiagnosticHolder(this, data) as E
 }

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

@@ -29,7 +29,7 @@ abstract class FirAnnotation : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotation(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnnotation(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -23,6 +23,6 @@ abstract class FirAnnotationArgumentMapping : FirPureAbstractElement(), FirEleme
     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 = 
+    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

@@ -33,7 +33,7 @@ abstract class FirAnnotationCall : FirAnnotation(), FirCall, FirResolvable {
     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 = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnnotationCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirAnonymousFunctionExpression : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousFunctionExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnonymousFunctionExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirAnonymousObjectExpression : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousObjectExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAnonymousObjectExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -22,7 +22,7 @@ abstract class FirArgumentList : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitArgumentList(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformArgumentList(this, data) as E
 
     abstract fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirArgumentList

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

@@ -24,7 +24,7 @@ abstract class FirArrayOfCall : FirExpression(), FirCall {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitArrayOfCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformArrayOfCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirAssignmentOperatorStatement : FirPureAbstractElement(), FirSta
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAssignmentOperatorStatement(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAssignmentOperatorStatement(this, data) as E
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAssignmentOperatorStatement

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

@@ -28,7 +28,7 @@ abstract class FirAugmentedArraySetCall : FirPureAbstractElement(), FirStatement
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAugmentedArraySetCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformAugmentedArraySetCall(this, data) as E
 
     abstract fun replaceCalleeReference(newCalleeReference: FirReference)

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

@@ -26,7 +26,7 @@ abstract class FirBinaryLogicExpression : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBinaryLogicExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformBinaryLogicExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -24,7 +24,7 @@ abstract class FirBlock : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBlock(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformBlock(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirBreakExpression : FirLoopJump() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBreakExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformBreakExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -22,7 +22,7 @@ sealed interface FirCall : FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCall(this, data) as E
 
     fun replaceArgumentList(newArgumentList: FirArgumentList)

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

@@ -34,7 +34,7 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableReferenceAccess(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCallableReferenceAccess(this, data) as E
 
     @FirImplementationDetail

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

@@ -24,7 +24,7 @@ abstract class FirCatch : FirPureAbstractElement(), FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCatch(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCatch(this, data) as E
 
     abstract fun <D> transformParameter(transformer: FirTransformer<D>, data: D): FirCatch

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

@@ -26,7 +26,7 @@ abstract class FirCheckNotNullCall : FirExpression(), FirCall, FirResolvable {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCheckNotNullCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCheckNotNullCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirCheckedSafeCallSubject : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCheckedSafeCallSubject(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformCheckedSafeCallSubject(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -24,7 +24,7 @@ abstract class FirClassReferenceExpression : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassReferenceExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformClassReferenceExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirComparisonExpression : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComparisonExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformComparisonExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -36,7 +36,7 @@ abstract class FirComponentCall : FirFunctionCall() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComponentCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformComponentCall(this, data) as E
 
     @FirImplementationDetail

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

@@ -26,7 +26,7 @@ abstract class FirConstExpression<T> : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformConstExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -21,7 +21,7 @@ interface FirContextReceiverArgumentListOwner : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContextReceiverArgumentListOwner(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformContextReceiverArgumentListOwner(this, data) as E
 
     fun replaceContextReceiverArguments(newContextReceiverArguments: List<FirExpression>)

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

@@ -25,7 +25,7 @@ abstract class FirContinueExpression : FirLoopJump() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContinueExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformContinueExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -31,7 +31,7 @@ abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolv
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDelegatedConstructorCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformDelegatedConstructorCall(this, data) as E
 
     abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)

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

@@ -25,7 +25,7 @@ abstract class FirDoWhileLoop : FirLoop() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDoWhileLoop(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformDoWhileLoop(this, data) as E
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirDoWhileLoop

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

@@ -27,7 +27,7 @@ abstract class FirElvisExpression : FirExpression(), FirResolvable {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElvisExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformElvisExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirEqualityOperatorCall : FirExpression(), FirCall {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEqualityOperatorCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformEqualityOperatorCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -36,7 +36,7 @@ abstract class FirErrorAnnotationCall : FirAnnotationCall(), FirDiagnosticHolder
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorAnnotationCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorAnnotationCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -28,7 +28,7 @@ abstract class FirErrorExpression : FirExpression(), FirDiagnosticHolder {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -28,7 +28,7 @@ abstract class FirErrorLoop : FirLoop(), FirDiagnosticHolder {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorLoop(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorLoop(this, data) as E
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorLoop

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

@@ -38,7 +38,7 @@ abstract class FirErrorResolvedQualifier : FirResolvedQualifier(), FirDiagnostic
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorResolvedQualifier(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformErrorResolvedQualifier(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -24,7 +24,7 @@ abstract class FirExpression : FirPureAbstractElement(), FirStatement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformExpression(this, data) as E
 
     abstract fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -35,7 +35,7 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunctionCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformFunctionCall(this, data) as E
 
     @FirImplementationDetail

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

@@ -25,7 +25,7 @@ abstract class FirGetClassCall : FirExpression(), FirCall {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitGetClassCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformGetClassCall(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -35,7 +35,7 @@ abstract class FirImplicitInvokeCall : FirFunctionCall() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitImplicitInvokeCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformImplicitInvokeCall(this, data) as E
 
     @FirImplementationDetail

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

@@ -35,7 +35,7 @@ abstract class FirIntegerLiteralOperatorCall : FirFunctionCall() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitIntegerLiteralOperatorCall(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformIntegerLiteralOperatorCall(this, data) as E
 
     @FirImplementationDetail

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

@@ -26,7 +26,7 @@ sealed class FirJump<E : FirTargetElement> : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitJump(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformJump(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirLambdaArgumentExpression : FirWrappedArgumentExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLambdaArgumentExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformLambdaArgumentExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -27,7 +27,7 @@ sealed class FirLoop : FirPureAbstractElement(), FirStatement, FirTargetElement
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLoop(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformLoop(this, data) as E
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLoop

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

@@ -25,7 +25,7 @@ abstract class FirLoopJump : FirJump<FirLoop>() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLoopJump(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformLoopJump(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -27,7 +27,7 @@ abstract class FirNamedArgumentExpression : FirWrappedArgumentExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitNamedArgumentExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformNamedArgumentExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -34,7 +34,7 @@ abstract class FirPropertyAccessExpression : FirQualifiedAccessExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPropertyAccessExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformPropertyAccessExpression(this, data) as E
 
     @FirImplementationDetail

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

@@ -30,7 +30,7 @@ interface FirQualifiedAccess : FirResolvable, FirStatement, FirContextReceiverAr
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccess(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformQualifiedAccess(this, data) as E
 
     override fun replaceCalleeReference(newCalleeReference: FirReference)

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

@@ -32,7 +32,7 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirQualifiedAcces
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccessExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformQualifiedAccessExpression(this, data) as E
 
     @FirImplementationDetail

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

@@ -28,7 +28,7 @@ abstract class FirQualifiedErrorAccessExpression : FirExpression(), FirDiagnosti
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedErrorAccessExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformQualifiedErrorAccessExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -22,7 +22,7 @@ sealed interface FirResolvable : FirElement {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvable(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvable(this, data) as E
 
     fun replaceCalleeReference(newCalleeReference: FirReference)

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

@@ -36,7 +36,7 @@ abstract class FirResolvedQualifier : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedQualifier(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvedQualifier(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -25,7 +25,7 @@ abstract class FirResolvedReifiedParameterReference : FirExpression() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedReifiedParameterReference(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformResolvedReifiedParameterReference(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)

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

@@ -27,7 +27,7 @@ abstract class FirReturnExpression : FirJump<FirFunction>() {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitReturnExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
-    override fun <E: FirElement, D> transform(transformer: FirTransformer<D>, data: D): E = 
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
         transformer.transformReturnExpression(this, data) as E
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)