[FIR] Add replaceCalleeReference to all FirResolvable

Also improve tree generator: now it generates abstract overrides
  for `replace` functions and correctly generates replace for fields
  with overriden type

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

@@ -41,6 +41,16 @@ abstract class FirAnonymousFunction : FirFunction<FirAnonymousFunction>, FirExpr
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousFunction(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract fun replaceInvocationKind(newInvocationKind: InvocationKind?)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousFunction

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

@@ -29,5 +29,7 @@ abstract class FirAnonymousInitializer : FirPureAbstractElement(), FirDeclaratio
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnonymousInitializer(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     abstract fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirAnonymousInitializer
 }

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

@@ -37,6 +37,12 @@ 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 replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
+
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformDeclarations(transformer: FirTransformer<D>, data: D): FirAnonymousObject
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnonymousObject

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

@@ -29,6 +29,10 @@ interface FirCallableDeclaration<F : FirCallableDeclaration<F>> : FirTypedDeclar
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableDeclaration(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
     fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
 
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableDeclaration<F>

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

@@ -32,6 +32,12 @@ interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : Fi
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableMemberDeclaration(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>
 
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirCallableMemberDeclaration<F>

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

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

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

@@ -27,5 +27,7 @@ interface FirClassLikeDeclaration<F : FirClassLikeDeclaration<F>> : FirDeclarati
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassLikeDeclaration(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassLikeDeclaration<F>
 }

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

@@ -41,6 +41,14 @@ abstract class FirConstructor : FirPureAbstractElement(), FirFunction<FirConstru
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstructor(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirConstructor
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirConstructor

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

@@ -43,6 +43,12 @@ abstract class FirEnumEntry : FirVariable<FirEnumEntry>(), FirCallableMemberDecl
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitEnumEntry(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirEnumEntry
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirEnumEntry

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

@@ -38,6 +38,14 @@ 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 replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorFunction
 
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorFunction

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

@@ -43,6 +43,12 @@ abstract class FirField : FirVariable<FirField>(), FirTypeParametersOwner, FirCa
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitField(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirField
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirField

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

@@ -30,5 +30,7 @@ abstract class FirFile : FirPureAbstractElement(), FirAnnotationContainer, FirDe
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFile(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFile
 }

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

@@ -37,6 +37,12 @@ interface FirFunction<F : FirFunction<F>> : FirCallableDeclaration<F>, FirTarget
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunction(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
 
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunction<F>

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

@@ -26,6 +26,8 @@ interface FirMemberDeclaration : FirDeclaration, FirAnnotationContainer {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitMemberDeclaration(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     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

@@ -48,6 +48,12 @@ abstract class FirProperty : FirVariable<FirProperty>(), FirTypeParametersOwner,
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitProperty(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirProperty
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirProperty

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

@@ -40,6 +40,16 @@ abstract class FirPropertyAccessor : FirPureAbstractElement(), FirFunction<FirPr
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitPropertyAccessor(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
+    abstract override fun replaceContractDescription(newContractDescription: FirContractDescription)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirPropertyAccessor
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirPropertyAccessor

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

@@ -41,6 +41,8 @@ abstract class FirRegularClass : FirPureAbstractElement(), FirMemberDeclaration,
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitRegularClass(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirRegularClass

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

@@ -42,6 +42,10 @@ abstract class FirSealedClass : FirRegularClass() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSealedClass(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
+
     abstract fun replaceInheritors(newInheritors: List<ClassId>)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSealedClass

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

@@ -42,6 +42,16 @@ abstract class FirSimpleFunction : FirPureAbstractElement(), FirFunction<FirSimp
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSimpleFunction(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
+    abstract override fun replaceContractDescription(newContractDescription: FirContractDescription)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirSimpleFunction
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirSimpleFunction

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

@@ -32,6 +32,8 @@ abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeAlias(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     abstract fun replaceExpandedTypeRef(newExpandedTypeRef: FirTypeRef)
 
     abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirTypeAlias

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

@@ -35,5 +35,7 @@ abstract class FirTypeParameter : FirPureAbstractElement(), FirTypeParameterRef,
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeParameter
 }

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

@@ -26,6 +26,8 @@ interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypedDeclaration(this, data)
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
     fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
 
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypedDeclaration

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

@@ -43,6 +43,12 @@ abstract class FirValueParameter : FirVariable<FirValueParameter>() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitValueParameter(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirValueParameter
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirValueParameter

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

@@ -41,6 +41,12 @@ abstract class FirVariable<F : FirVariable<F>> : FirPureAbstractElement(), FirCa
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVariable(this, data)
 
+    abstract override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverTypeRef(newReceiverTypeRef: FirTypeRef?)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<F>
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirVariable<F>

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

@@ -26,6 +26,10 @@ abstract class FirAnnotationCall : FirExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitAnnotationCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     abstract fun replaceResolved(newResolved: Boolean)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirAnnotationCall

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

@@ -22,5 +22,9 @@ abstract class FirArrayOfCall : FirExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitArrayOfCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirArrayOfCall
 }

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 replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpression
 
     abstract fun <D> transformLeftOperand(transformer: FirTransformer<D>, data: D): FirBinaryLogicExpression

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

@@ -23,5 +23,7 @@ abstract class FirBreakExpression : FirLoopJump() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitBreakExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirBreakExpression
 }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -29,6 +30,14 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCallableReferenceAccess(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract fun replaceCalleeReference(newCalleeReference: FirNamedReference)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirCallableReferenceAccess

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

@@ -24,6 +24,12 @@ 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 replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     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

@@ -22,5 +22,7 @@ abstract class FirClassReferenceExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitClassReferenceExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirClassReferenceExpression
 }

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

@@ -23,5 +23,7 @@ abstract class FirComparisonExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComparisonExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirComparisonExpression
 }

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -31,6 +32,16 @@ abstract class FirComponentCall : FirFunctionCall() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitComponentCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirNamedReference)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirComponentCall
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirComponentCall

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

@@ -23,6 +23,8 @@ abstract class FirConstExpression<T> : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     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

@@ -23,5 +23,7 @@ abstract class FirContinueExpression : FirLoopJump() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitContinueExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirContinueExpression
 }

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

@@ -27,6 +27,10 @@ abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolv
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDelegatedConstructorCall(this, data)
 
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     abstract fun replaceConstructedTypeRef(newConstructedTypeRef: FirTypeRef)
 
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall

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

@@ -24,5 +24,7 @@ abstract class FirErrorExpression : FirExpression(), FirDiagnosticHolder {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorExpression
 }

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

@@ -33,6 +33,12 @@ abstract class FirExpressionWithSmartcast : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitExpressionWithSmartcast(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -30,6 +31,16 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunctionCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    abstract fun replaceCalleeReference(newCalleeReference: FirNamedReference)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirFunctionCall
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirFunctionCall

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

@@ -23,5 +23,9 @@ abstract class FirGetClassCall : FirExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitGetClassCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirGetClassCall
 }

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

@@ -24,5 +24,7 @@ abstract class FirJump<E : FirTargetElement> : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitJump(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJump<E>
 }

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

@@ -23,5 +23,7 @@ abstract class FirLambdaArgumentExpression : FirWrappedArgumentExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLambdaArgumentExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLambdaArgumentExpression
 }

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

@@ -23,5 +23,7 @@ abstract class FirLoopJump : FirJump<FirLoop>() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitLoopJump(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLoopJump
 }

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

@@ -25,5 +25,7 @@ abstract class FirNamedArgumentExpression : FirWrappedArgumentExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitNamedArgumentExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirNamedArgumentExpression
 }

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

@@ -23,5 +23,9 @@ abstract class FirOperatorCall : FirExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitOperatorCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     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,10 @@ interface FirQualifiedAccess : FirQualifiedAccessWithoutCallee, FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccess(this, data)
 
+    override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
     override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccess

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

@@ -29,6 +29,12 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirQualifiedAcces
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccessExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression

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

@@ -21,5 +21,7 @@ interface FirResolvable : FirElement {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvable(this, data)
 
+    fun replaceCalleeReference(newCalleeReference: FirReference)
+
     fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirResolvable
 }

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

@@ -31,6 +31,8 @@ abstract class FirResolvedQualifier : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedQualifier(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract fun replaceSafe(newSafe: Boolean)
 
     abstract fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)

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

@@ -23,5 +23,7 @@ abstract class FirResolvedReifiedParameterReference : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedReifiedParameterReference(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     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 replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirReturnExpression
 
     abstract fun <D> transformResult(transformer: FirTransformer<D>, data: D): FirReturnExpression

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

@@ -23,5 +23,7 @@ abstract class FirSpreadArgumentExpression : FirWrappedArgumentExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitSpreadArgumentExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirSpreadArgumentExpression
 }

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

@@ -22,5 +22,9 @@ abstract class FirStringConcatenationCall : FirCall, FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitStringConcatenationCall(this, data)
 
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirStringConcatenationCall
 }

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -29,6 +30,14 @@ abstract class FirThisReceiverExpression : FirQualifiedAccessExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitThisReceiverExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract fun replaceCalleeReference(newCalleeReference: FirThisReference)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirThisReceiverExpression
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirThisReceiverExpression

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

@@ -22,5 +22,7 @@ abstract class FirThrowExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitThrowExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     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,10 @@ abstract class FirTryExpression : FirExpression(), FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTryExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTryExpression
 
     abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirTryExpression

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

@@ -24,5 +24,9 @@ abstract class FirTypeOperatorCall : FirExpression(), FirCall {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitTypeOperatorCall(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeOperatorCall
 }

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

@@ -23,5 +23,7 @@ abstract class FirVarargArgumentsExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVarargArgumentsExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     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,10 @@ abstract class FirVariableAssignment : FirPureAbstractElement(), FirQualifiedAcc
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVariableAssignment(this, data)
 
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirVariableAssignment

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

@@ -28,6 +28,10 @@ abstract class FirWhenExpression : FirExpression(), FirResolvable {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWhenExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract fun replaceIsExhaustive(newIsExhaustive: Boolean)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWhenExpression

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

@@ -23,5 +23,7 @@ abstract class FirWhenSubjectExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWhenSubjectExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWhenSubjectExpression
 }

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

@@ -23,5 +23,7 @@ abstract class FirWrappedArgumentExpression : FirWrappedExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedArgumentExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedArgumentExpression
 }

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

@@ -23,5 +23,7 @@ abstract class FirWrappedDelegateExpression : FirWrappedExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedDelegateExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedDelegateExpression
 }

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

@@ -22,5 +22,7 @@ abstract class FirWrappedExpression : FirExpression() {
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitWrappedExpression(this, data)
 
+    abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirWrappedExpression
 }

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

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirCallableReferenceAccessImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirComponentCallImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirThisReceiverExpressionImpl
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -98,4 +99,13 @@ internal class FirCallableReferenceAccessImpl(
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirNamedReference) {
+        calleeReference = newCalleeReference
+    }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        require(newCalleeReference is FirNamedReference)
+        replaceCalleeReference(newCalleeReference)
+    }
 }

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

@@ -57,4 +57,8 @@ internal class FirCheckNotNullCallImpl(
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
         argumentList = newArgumentList
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
 }

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirComponentCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -112,4 +113,13 @@ internal class FirComponentCallImpl(
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
         argumentList = newArgumentList
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirNamedReference) {
+        calleeReference = newCalleeReference
+    }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        require(newCalleeReference is FirNamedReference)
+        replaceCalleeReference(newCalleeReference)
+    }
 }

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

@@ -55,6 +55,10 @@ internal class FirDelegatedConstructorCallImpl(
         return this
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
         argumentList = newArgumentList
     }

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.references.FirNamedReference
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -107,4 +108,13 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
         argumentList = newArgumentList
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirNamedReference) {
+        calleeReference = newCalleeReference
+    }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        require(newCalleeReference is FirNamedReference)
+        replaceCalleeReference(newCalleeReference)
+    }
 }

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

@@ -98,4 +98,8 @@ internal class FirQualifiedAccessExpressionImpl(
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
 }

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

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -100,4 +101,13 @@ internal class FirThisReceiverExpressionImpl(
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirThisReference) {
+        calleeReference = newCalleeReference
+    }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        require(newCalleeReference is FirThisReference)
+        replaceCalleeReference(newCalleeReference)
+    }
 }

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

@@ -80,4 +80,8 @@ internal class FirTryExpressionImpl(
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
         typeRef = newTypeRef
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
 }

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

@@ -104,4 +104,8 @@ internal class FirVariableAssignmentImpl(
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
 }

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

@@ -85,6 +85,10 @@ internal class FirWhenExpressionImpl(
         typeRef = newTypeRef
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
     override fun replaceIsExhaustive(newIsExhaustive: Boolean) {
         isExhaustive = newIsExhaustive
     }

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

@@ -75,5 +75,9 @@ internal class FirExpressionWithSmartcastImpl(
         throw IllegalStateException()
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        throw IllegalStateException()
+    }
+
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 }

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.tree.generator
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.annotations
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.arguments
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.body
+import org.jetbrains.kotlin.fir.tree.generator.FieldSets.calleeReference
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.classKind
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.controlFlowGraphReferenceField
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.declarations
@@ -62,7 +63,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         }
 
         resolvable.configure {
-            +field("calleeReference", reference).withTransform()
+            +calleeReference.withTransform()
         }
 
         diagnosticHolder.configure {
@@ -440,7 +441,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         }
 
         callableReferenceAccess.configure {
-            +field("calleeReference", namedReference)
+            +field("calleeReference", namedReference, withReplace = true).withTransform()
         }
 
         getClassCall.configure {

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.tree.generator.model
 
 import org.jetbrains.kotlin.fir.tree.generator.printer.BASE_PACKAGE
 import org.jetbrains.kotlin.fir.tree.generator.printer.typeWithArguments
+import org.jetbrains.kotlin.fir.tree.generator.util.set
 
 interface KindOwner : Importable {
     var kind: Implementation.Kind?
@@ -31,6 +32,7 @@ interface AbstractElement : FieldContainer, KindOwner {
     val allFirFields: List<Field>
     val defaultImplementation: Implementation?
     val customImplementations: List<Implementation>
+    val overridenFields: Map<Field, Map<Importable, Boolean>>
 
     override val allParents: List<KindOwner> get() = parents
 }
@@ -60,10 +62,10 @@ class Element(val name: String, kind: Kind) : AbstractElement {
     override var doesNotNeedImplementation: Boolean = false
 
     override val needTransformOtherChildren: Boolean get() = _needTransformOtherChildren || parents.any { it.needTransformOtherChildren }
-
+    override val overridenFields: MutableMap<Field, MutableMap<Importable, Boolean>> = mutableMapOf()
     override val allImplementations: List<Implementation> by lazy {
         if (doesNotNeedImplementation) {
-            emptyList<Implementation>()
+            emptyList()
         } else {
             val implementations = customImplementations.toMutableList()
             defaultImplementation?.let { implementations += it }
@@ -74,13 +76,23 @@ class Element(val name: String, kind: Kind) : AbstractElement {
     override val allFields: List<Field> by lazy {
         val result = LinkedHashSet<Field>()
         result.addAll(fields.toList().asReversed())
-        for (field in parentFields.asReversed()) {
+        result.forEach { overridenFields[it, it] = false }
-            val overrides = !result.add(field)
+        for (parentField in parentFields.asReversed()) {
+            val overrides = !result.add(parentField)
             if (overrides) {
-                val existingField = result.first { it == field }
+                val existingField = result.first { it == parentField }
                 existingField.fromParent = true
-                existingField.needsSeparateTransform = existingField.needsSeparateTransform || field.needsSeparateTransform
+                existingField.needsSeparateTransform = existingField.needsSeparateTransform || parentField.needsSeparateTransform
-                existingField.needTransformInOtherChildren = existingField.needTransformInOtherChildren || field.needTransformInOtherChildren
+                existingField.needTransformInOtherChildren = existingField.needTransformInOtherChildren || parentField.needTransformInOtherChildren
+                existingField.withReplace = parentField.withReplace || existingField.withReplace
+                if (parentField.type != existingField.type && parentField.withReplace) {
+                    existingField.overridenTypes += parentField
+                    overridenFields[existingField, parentField] = false
+                } else {
+                    overridenFields[existingField, parentField] = true
+                }
+            } else {
+                overridenFields[parentField, parentField] = true
             }
         }
         result.toList().asReversed()
@@ -160,4 +172,4 @@ class TypeArgumentWithMultipleUpperBounds(name: String, override val upperBounds
     override fun toString(): String {
         return name
     }
-}
+}

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

@@ -11,7 +11,7 @@ sealed class Field : Importable {
     abstract val name: String
     open val arguments = mutableListOf<Importable>()
     abstract val nullable: Boolean
-    abstract val withReplace: Boolean
+    open var withReplace: Boolean = false
     abstract val isFirType: Boolean
 
     var fromParent: Boolean = false
@@ -22,10 +22,11 @@ sealed class Field : Importable {
     abstract var isMutable: Boolean
     open var isMutableInInterface: Boolean = false
     open val withGetter: Boolean get() = false
-    open val isLateinit: Boolean get() = false
     open val customSetter: String? get() = null
     open val fromDelegate: Boolean get() = false
 
+    open val overridenTypes: MutableSet<Importable> = mutableSetOf()
+
     fun copy(): Field = internalCopy().also {
         updateFieldsInCopy(it)
     }
@@ -37,6 +38,7 @@ sealed class Field : Importable {
             copy.needsSeparateTransform = needsSeparateTransform
             copy.needTransformInOtherChildren = needTransformInOtherChildren
             copy.isMutable = isMutable
+            copy.overridenTypes += overridenTypes
         }
         copy.fromParent = fromParent
     }
@@ -66,7 +68,9 @@ class FieldWithDefault(val origin: Field) : Field() {
     override val name: String get() = origin.name
     override val type: String get() = origin.type
     override val nullable: Boolean get() = origin.nullable
-    override val withReplace: Boolean get() = origin.withReplace
+    override var withReplace: Boolean
+        get() = origin.withReplace
+        set(_) {}
     override val packageName: String? get() = origin.packageName
     override val isFirType: Boolean get() = origin.isFirType
     override var needsSeparateTransform: Boolean
@@ -91,6 +95,8 @@ class FieldWithDefault(val origin: Field) : Field() {
     override var customSetter: String? = null
     override var fromDelegate: Boolean = false
     var needAcceptAndTransform: Boolean = true
+    override val overridenTypes: MutableSet<Importable>
+        get() = origin.overridenTypes
 
     override fun internalCopy(): Field {
         return FieldWithDefault(origin).also {
@@ -109,7 +115,7 @@ class SimpleField(
     override val packageName: String?,
     val customType: Importable? = null,
     override val nullable: Boolean,
-    override val withReplace: Boolean
+    override var withReplace: Boolean
 ) : Field() {
     override val isFirType: Boolean = false
     override val fullQualifiedName: String?
@@ -144,7 +150,7 @@ class FirField(
     override val name: String,
     val element: AbstractElement,
     override val nullable: Boolean,
-    override val withReplace: Boolean
+    override var withReplace: Boolean
 ) : Field() {
     init {
         if (element is ElementWithArguments) {
@@ -173,7 +179,7 @@ class FirField(
 class FieldList(
     override val name: String,
     val baseType: Importable,
-    override val withReplace: Boolean
+    override var withReplace: Boolean
 ) : Field() {
     override var defaultValueInImplementation: String? = null
     override val packageName: String? get() = baseType.packageName

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

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.fir.tree.generator.printer
 
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
-import org.jetbrains.kotlin.fir.tree.generator.model.Element
+import org.jetbrains.kotlin.fir.tree.generator.model.*
-import org.jetbrains.kotlin.fir.tree.generator.model.Implementation
 import org.jetbrains.kotlin.fir.tree.generator.pureAbstractElementType
+import org.jetbrains.kotlin.fir.tree.generator.util.get
 
 import java.io.File
 
@@ -84,11 +84,18 @@ fun SmartPrinter.printElement(element: Element) {
             override()
             println("fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visit$name(this, data)")
 
-            fields.filter { it.withReplace }.forEach {
+            fun Field.replaceDeclaration(override: Boolean, overridenType: Importable? = null) {
                 println()
                 abstract()
-                if (it.fromParent) print("override ")
+                if (override) print("override ")
-                println(it.replaceFunctionDeclaration())
+                println(replaceFunctionDeclaration(overridenType))
+            }
+
+            allFields.filter { it.withReplace }.forEach {
+                it.replaceDeclaration(overridenFields[it, it])
+                for (overridenType in it.overridenTypes) {
+                    it.replaceDeclaration(true, overridenType)
+                }
             }
 
             for (field in allFields) {

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

@@ -302,22 +302,30 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                 }
             }
 
-            for (field in allFields.filter { it.withReplace }) {
+            fun generateReplace(field: Field, overridenType: Importable? = null, body: () -> Unit) {
                 println()
                 abstract()
-                print("override ${field.replaceFunctionDeclaration()}")
+                print("override ${field.replaceFunctionDeclaration(overridenType)}")
                 if (isInterface || isAbstract) {
                     println()
-                    continue
+                    return
                 }
                 print(" {")
                 if (!field.isMutable) {
                     println("}")
-                    continue
+                    return
                 }
                 println()
                 withIndent {
-                    val newValue = "new${field.name.capitalize()}"
+                    body()
+                }
+                println("}")
+            }
+
+            for (field in allFields.filter { it.withReplace }) {
+                val capitalizedFieldName = field.name.capitalize()
+                val newValue = "new$capitalizedFieldName"
+                generateReplace(field) {
                     when {
                         field.withGetter -> {}
 
@@ -331,7 +339,13 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                         }
                     }
                 }
-                println("}")
+
+                for (overridenType in field.overridenTypes) {
+                    generateReplace(field, overridenType) {
+                        println("require($newValue is ${field.typeWithArguments})")
+                        println("replace$capitalizedFieldName($newValue)")
+                    }
+                }
             }
         }
         println("}")

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

@@ -62,6 +62,7 @@ fun Element.collectImports(): List<String> {
 
 private fun Element.collectImportsInternal(base: List<String>, kind: ImportKind): List<String> {
     val fqns = base + allFields.mapNotNull { it.fullQualifiedName } +
+            allFields.flatMap { it.overridenTypes.mapNotNull { it.fullQualifiedName } } +
             allFields.flatMap { it.arguments.mapNotNull { it.fullQualifiedName } } +
             typeArguments.flatMap { it.upperBounds.mapNotNull { it.fullQualifiedName } }
     return fqns.filterRedundantImports(packageName, kind)
@@ -93,9 +94,10 @@ fun transformFunctionDeclaration(transformName: String, returnType: String): Str
     return "fun <D> transform$transformName(transformer: FirTransformer<D>, data: D): $returnType"
 }
 
-fun Field.replaceFunctionDeclaration(): String {
+fun Field.replaceFunctionDeclaration(overridenType: Importable? = null): String {
     val capName = name.capitalize()
-    return "fun replace$capName(new$capName: $typeWithArguments)"
+    val type = overridenType?.typeWithArguments ?: typeWithArguments
+    return "fun replace$capName(new$capName: $type)"
 }
 
 val Field.mutableType: String

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

@@ -11,3 +11,13 @@ fun Element.traverseParents(block: (Element) -> Unit) {
     block(this)
     parents.forEach { it.traverseParents(block) }
 }
+
+operator fun <K, V, U> MutableMap<K, MutableMap<V, U>>.set(k1: K, k2: V, value: U) {
+    this.putIfAbsent(k1, mutableMapOf())
+    val map = getValue(k1)
+    map[k2] = value
+}
+
+operator fun <K, V, U> Map<K, Map<V, U>>.get(k1: K, k2: V): U {
+    return getValue(k1).getValue(k2)
+}