FIR: Simplify FirQualifiedAccess hiearchy

Mostly, it's getting rid of FirQualifiedAccessWithoutCallee and FirModifiableQualifiedAccess
The latter was only used during FIR building to set explicit receiver
that might be done by replace call on explicit receiver

The problem with replaceExplicitReceiver is that for FirComponentCall
explicitReceiver should be not null, so it's needed to perform those tricks
at the generatot

compiler/fir/raw-fir/fir-common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -462,12 +461,7 @@ private fun FirExpression.checkReceiver(name: String?): Boolean {
 }
 
 
-fun FirModifiableQualifiedAccess.wrapWithSafeCall(receiver: FirExpression): FirSafeCallExpression {
+fun FirQualifiedAccess.wrapWithSafeCall(receiver: FirExpression): FirSafeCallExpression {
-    // TODO: Refactor tree to make FirModifiableQualifiedAccess inherit FirQualifiedAccess
-    require(this is FirQualifiedAccess) {
-        "Safe-call instances are expected to be FirQualifiedAccess, but ${this::class} was found"
-    }
-
     val checkedSafeCallSubject = buildCheckedSafeCallSubject {
         @OptIn(FirContractViolation::class)
         this.originalReceiverRef = FirExpressionRef<FirExpression>().apply {
@@ -475,7 +469,7 @@ fun FirModifiableQualifiedAccess.wrapWithSafeCall(receiver: FirExpression): FirS
         }
     }
 
-    explicitReceiver = checkedSafeCallSubject
+    replaceExplicitReceiver(checkedSafeCallSubject)
     return buildSafeCallExpression {
         this.receiver = receiver
         @OptIn(FirContractViolation::class)

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
@@ -475,12 +474,12 @@ class ExpressionsConverter(
             }
         }
 
-        (firSelector as? FirModifiableQualifiedAccess)?.let {
+        (firSelector as? FirQualifiedAccess)?.let {
             if (isSafe) {
                 return it.wrapWithSafeCall(firReceiver!!)
             }
 
-            it.explicitReceiver = firReceiver
+            it.replaceExplicitReceiver(firReceiver)
         }
         return firSelector
     }

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
-import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.builder.*
@@ -1810,14 +1809,14 @@ class RawFirBuilder(
                     expression.toFirSourceElement(), ConeSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax),
                 )
             val firSelector = selector.toFirExpression("Incorrect selector expression")
-            if (firSelector is FirModifiableQualifiedAccess) {
+            if (firSelector is FirQualifiedAccess) {
                 val receiver = expression.receiverExpression.toFirExpression("Incorrect receiver expression")
 
                 if (expression is KtSafeQualifiedExpression) {
                     return firSelector.wrapWithSafeCall(receiver)
                 }
 
-                firSelector.explicitReceiver = receiver
+                firSelector.replaceExplicitReceiver(receiver)
             }
             return firSelector
         }

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

@@ -34,6 +34,8 @@ abstract class FirCallableReferenceAccess : FirQualifiedAccessExpression() {
 
     abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     abstract fun replaceCalleeReference(newCalleeReference: FirNamedReference)
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)

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

@@ -41,6 +41,8 @@ abstract class FirComponentCall : FirFunctionCall() {
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     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/FirDelegatedConstructorCall.kt

@@ -18,25 +18,25 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 abstract class FirDelegatedConstructorCall : FirPureAbstractElement(), FirResolvable, FirCall {
     abstract override val source: FirSourceElement?
-    abstract override val calleeReference: FirReference
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val argumentList: FirArgumentList
     abstract val constructedTypeRef: FirTypeRef
     abstract val dispatchReceiver: FirExpression
+    abstract override val calleeReference: FirReference
     abstract val isThis: Boolean
     abstract val isSuper: Boolean
 
     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
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall
 
     abstract fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall
+
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCall
 }

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

@@ -21,11 +21,11 @@ abstract class FirExpressionWithSmartcast : FirQualifiedAccessExpression() {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
+    abstract override val calleeReference: FirReference
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
     abstract override val dispatchReceiver: FirExpression
     abstract override val extensionReceiver: FirExpression
-    abstract override val calleeReference: FirReference
     abstract val originalExpression: FirQualifiedAccessExpression
     abstract val typesFromSmartCast: Collection<ConeKotlinType>
     abstract val originalType: FirTypeRef
@@ -34,12 +34,16 @@ abstract class FirExpressionWithSmartcast : FirQualifiedAccessExpression() {
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
 
-    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
-
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
+    abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
@@ -47,6 +51,4 @@ abstract class FirExpressionWithSmartcast : FirQualifiedAccessExpression() {
     abstract override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 
     abstract override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
-
-    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirExpressionWithSmartcast
 }

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

@@ -34,6 +34,8 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
 
     abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     abstract override fun replaceArgumentList(newArgumentList: FirArgumentList)
 
     abstract fun replaceCalleeReference(newCalleeReference: FirNamedReference)

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

@@ -15,30 +15,32 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-interface FirQualifiedAccess : FirQualifiedAccessWithoutCallee, FirResolvable {
+interface FirQualifiedAccess : FirResolvable, FirStatement {
     override val source: FirSourceElement?
-    override val annotations: List<FirAnnotationCall>
-    override val typeArguments: List<FirTypeProjection>
-    override val explicitReceiver: FirExpression?
-    override val dispatchReceiver: FirExpression
-    override val extensionReceiver: FirExpression
     override val calleeReference: FirReference
+    override val annotations: List<FirAnnotationCall>
+    val typeArguments: List<FirTypeProjection>
+    val explicitReceiver: FirExpression?
+    val dispatchReceiver: FirExpression
+    val extensionReceiver: FirExpression
 
     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)
 
+    fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
-    override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+    fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
-    override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+    fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
-    override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+    fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 
-    override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
+    fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
-
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccess
 }

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

@@ -20,22 +20,26 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirQualifiedAcces
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
+    abstract override val calleeReference: FirReference
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
     abstract override val dispatchReceiver: FirExpression
     abstract override val extensionReceiver: FirExpression
-    abstract override val calleeReference: FirReference
 
     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 replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
+
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
+
     abstract override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 
     abstract override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
@@ -43,6 +47,4 @@ abstract class FirQualifiedAccessExpression : FirExpression(), FirQualifiedAcces
     abstract override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 
     abstract override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
-
-    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpression
 }

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

@@ -1,38 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir.expressions
-
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-interface FirQualifiedAccessWithoutCallee : FirStatement {
-    override val source: FirSourceElement?
-    override val annotations: List<FirAnnotationCall>
-    val typeArguments: List<FirTypeProjection>
-    val explicitReceiver: FirExpression?
-    val dispatchReceiver: FirExpression
-    val extensionReceiver: FirExpression
-
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitQualifiedAccessWithoutCallee(this, data)
-
-    fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
-
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
-
-    fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
-
-    fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
-
-    fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
-
-    fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccessWithoutCallee
-}

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

@@ -33,6 +33,8 @@ abstract class FirThisReceiverExpression : FirQualifiedAccessExpression() {
 
     abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
     abstract fun replaceCalleeReference(newCalleeReference: FirThisReference)
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)

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

@@ -18,20 +18,24 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 abstract class FirVariableAssignment : FirPureAbstractElement(), FirQualifiedAccess {
     abstract override val source: FirSourceElement?
+    abstract override val calleeReference: FirReference
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val typeArguments: List<FirTypeProjection>
     abstract override val explicitReceiver: FirExpression?
     abstract override val dispatchReceiver: FirExpression
     abstract override val extensionReceiver: FirExpression
-    abstract override val calleeReference: FirReference
     abstract val lValue: FirReference
     abstract val rValue: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitVariableAssignment(this, data)
 
+    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+
     abstract override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
 
-    abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
+    abstract override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?)
+
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 
     abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 
@@ -43,7 +47,5 @@ abstract class FirVariableAssignment : FirPureAbstractElement(), FirQualifiedAcc
 
     abstract override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 
-    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirVariableAssignment
-
     abstract fun <D> transformRValue(transformer: FirTransformer<D>, data: D): FirVariableAssignment
 }

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

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
 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

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

@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
 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

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

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 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.FirQualifiedAccessExpressionImpl
 import org.jetbrains.kotlin.fir.references.FirReference
@@ -33,22 +32,22 @@ class FirQualifiedAccessExpressionBuilder : FirQualifiedAccessBuilder, FirAnnota
     override var source: FirSourceElement? = null
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
+    lateinit var calleeReference: FirReference
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
     override var dispatchReceiver: FirExpression = FirNoReceiverExpression
     override var extensionReceiver: FirExpression = FirNoReceiverExpression
-    lateinit var calleeReference: FirReference
 
     override fun build(): FirQualifiedAccessExpression {
         return FirQualifiedAccessExpressionImpl(
             source,
             typeRef,
             annotations,
+            calleeReference,
             typeArguments,
             explicitReceiver,
             dispatchReceiver,
             extensionReceiver,
-            calleeReference,
         )
     }
 

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

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 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

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
 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.FirVariableAssignmentImpl
 import org.jetbrains.kotlin.fir.references.FirReference
@@ -28,23 +27,23 @@ import org.jetbrains.kotlin.fir.visitors.*
 @FirBuilderDsl
 class FirVariableAssignmentBuilder : FirQualifiedAccessBuilder, FirAnnotationContainerBuilder {
     override var source: FirSourceElement? = null
+    lateinit var calleeReference: FirReference
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val typeArguments: MutableList<FirTypeProjection> = mutableListOf()
     override var explicitReceiver: FirExpression? = null
     override var dispatchReceiver: FirExpression = FirNoReceiverExpression
     override var extensionReceiver: FirExpression = FirNoReceiverExpression
-    lateinit var calleeReference: FirReference
     lateinit var rValue: FirExpression
 
     override fun build(): FirVariableAssignment {
         return FirVariableAssignmentImpl(
             source,
+            calleeReference,
             annotations,
             typeArguments,
             explicitReceiver,
             dispatchReceiver,
             extensionReceiver,
-            calleeReference,
             rValue,
         )
     }

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 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
@@ -31,7 +30,7 @@ internal class FirCallableReferenceAccessImpl(
     override var extensionReceiver: FirExpression,
     override var calleeReference: FirNamedReference,
     override var hasQuestionMarkAtLHS: Boolean,
-) : FirCallableReferenceAccess(), FirModifiableQualifiedAccess {
+) : FirCallableReferenceAccess() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
@@ -100,6 +99,10 @@ internal class FirCallableReferenceAccessImpl(
         typeArguments.addAll(newTypeArguments)
     }
 
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
+        explicitReceiver = newExplicitReceiver
+    }
+
     override fun replaceCalleeReference(newCalleeReference: FirNamedReference) {
         calleeReference = newCalleeReference
     }

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

@@ -121,4 +121,9 @@ internal class FirComponentCallImpl(
         require(newCalleeReference is FirNamedReference)
         replaceCalleeReference(newCalleeReference)
     }
+
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
+        require(newExplicitReceiver != null)
+        explicitReceiver = newExplicitReceiver
+    }
 }

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

@@ -33,22 +33,17 @@ internal class FirDelegatedConstructorCallImpl(
     override val isSuper: Boolean get() = !isThis
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        calleeReference.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
         argumentList.accept(visitor, data)
         constructedTypeRef.accept(visitor, data)
+        calleeReference.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCallImpl {
-        transformCalleeReference(transformer, data)
         transformAnnotations(transformer, data)
         argumentList = argumentList.transformSingle(transformer, data)
         constructedTypeRef = constructedTypeRef.transformSingle(transformer, data)
-        return this
+        transformCalleeReference(transformer, data)
-    }
-
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCallImpl {
-        calleeReference = calleeReference.transformSingle(transformer, data)
         return this
     }
 
@@ -62,8 +57,9 @@ internal class FirDelegatedConstructorCallImpl(
         return this
     }
 
-    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirDelegatedConstructorCallImpl {
-        calleeReference = newCalleeReference
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        return this
     }
 
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
@@ -73,4 +69,8 @@ internal class FirDelegatedConstructorCallImpl(
     override fun replaceConstructedTypeRef(newConstructedTypeRef: FirTypeRef) {
         constructedTypeRef = newConstructedTypeRef
     }
+
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
 }

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

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 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
@@ -33,7 +32,7 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override var extensionReceiver: FirExpression,
     override var argumentList: FirArgumentList,
     override var calleeReference: FirNamedReference,
-) : FirFunctionCall(), FirModifiableQualifiedAccess {
+) : FirFunctionCall() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
@@ -104,6 +103,10 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
         typeArguments.addAll(newTypeArguments)
     }
 
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
+        explicitReceiver = newExplicitReceiver
+    }
+
     override fun replaceArgumentList(newArgumentList: FirArgumentList) {
         argumentList = newArgumentList
     }

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

@@ -1,41 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir.expressions.impl
-
-import org.jetbrains.kotlin.fir.FirImplementationDetail
-import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.visitors.*
-
-/*
- * This file was generated automatically
- * DO NOT MODIFY IT MANUALLY
- */
-
-interface FirModifiableQualifiedAccess : FirQualifiedAccessWithoutCallee {
-    override val source: FirSourceElement?
-    override val annotations: MutableList<FirAnnotationCall>
-    override val typeArguments: MutableList<FirTypeProjection>
-    override var explicitReceiver: FirExpression?
-    override var dispatchReceiver: FirExpression
-    override var extensionReceiver: FirExpression
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-
-    override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>)
-}

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -24,15 +23,16 @@ internal class FirQualifiedAccessExpressionImpl(
     override val source: FirSourceElement?,
     override var typeRef: FirTypeRef,
     override val annotations: MutableList<FirAnnotationCall>,
+    override var calleeReference: FirReference,
     override val typeArguments: MutableList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
     override var dispatchReceiver: FirExpression,
     override var extensionReceiver: FirExpression,
-    override var calleeReference: FirReference,
+) : FirQualifiedAccessExpression() {
-) : FirQualifiedAccessExpression(), FirModifiableQualifiedAccess {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
+        calleeReference.accept(visitor, data)
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -41,12 +41,12 @@ internal class FirQualifiedAccessExpressionImpl(
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
             extensionReceiver.accept(visitor, data)
         }
-        calleeReference.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpressionImpl {
         typeRef = typeRef.transformSingle(transformer, data)
         transformAnnotations(transformer, data)
+        transformCalleeReference(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
         if (dispatchReceiver !== explicitReceiver) {
@@ -55,7 +55,6 @@ internal class FirQualifiedAccessExpressionImpl(
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
             extensionReceiver = extensionReceiver.transformSingle(transformer, data)
         }
-        transformCalleeReference(transformer, data)
         return this
     }
 
@@ -64,6 +63,11 @@ internal class FirQualifiedAccessExpressionImpl(
         return this
     }
 
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpressionImpl {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        return this
+    }
+
     override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpressionImpl {
         typeArguments.transformInplace(transformer, data)
         return this
@@ -84,21 +88,20 @@ internal class FirQualifiedAccessExpressionImpl(
         return this
     }
 
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccessExpressionImpl {
-        calleeReference = calleeReference.transformSingle(transformer, data)
-        return this
-    }
-
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
         typeRef = newTypeRef
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
     override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>) {
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
 
-    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
-        calleeReference = newCalleeReference
+        explicitReceiver = newExplicitReceiver
     }
 }

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 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
@@ -28,7 +27,7 @@ internal class FirThisReceiverExpressionImpl(
     override val annotations: MutableList<FirAnnotationCall>,
     override val typeArguments: MutableList<FirTypeProjection>,
     override var calleeReference: FirThisReference,
-) : FirThisReceiverExpression(), FirModifiableQualifiedAccess {
+) : FirThisReceiverExpression() {
     override var explicitReceiver: FirExpression? = null
     override var dispatchReceiver: FirExpression = FirNoReceiverExpression
     override var extensionReceiver: FirExpression = FirNoReceiverExpression
@@ -101,6 +100,10 @@ internal class FirThisReceiverExpressionImpl(
         typeArguments.addAll(newTypeArguments)
     }
 
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
+        explicitReceiver = newExplicitReceiver
+    }
+
     override fun replaceCalleeReference(newCalleeReference: FirThisReference) {
         calleeReference = newCalleeReference
     }

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

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.visitors.*
@@ -21,14 +20,14 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirVariableAssignmentImpl(
     override val source: FirSourceElement?,
+    override var calleeReference: FirReference,
     override val annotations: MutableList<FirAnnotationCall>,
     override val typeArguments: MutableList<FirTypeProjection>,
     override var explicitReceiver: FirExpression?,
     override var dispatchReceiver: FirExpression,
     override var extensionReceiver: FirExpression,
-    override var calleeReference: FirReference,
     override var rValue: FirExpression,
-) : FirVariableAssignment(), FirModifiableQualifiedAccess {
+) : FirVariableAssignment() {
     override var lValue: FirReference 
         get() = calleeReference
         set(value) {
@@ -36,6 +35,7 @@ internal class FirVariableAssignmentImpl(
         }
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        calleeReference.accept(visitor, data)
         annotations.forEach { it.accept(visitor, data) }
         typeArguments.forEach { it.accept(visitor, data) }
         explicitReceiver?.accept(visitor, data)
@@ -45,11 +45,11 @@ internal class FirVariableAssignmentImpl(
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
             extensionReceiver.accept(visitor, data)
         }
-        calleeReference.accept(visitor, data)
         rValue.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
+        transformCalleeReference(transformer, data)
         transformAnnotations(transformer, data)
         transformTypeArguments(transformer, data)
         explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
@@ -59,11 +59,15 @@ internal class FirVariableAssignmentImpl(
         if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
             extensionReceiver = extensionReceiver.transformSingle(transformer, data)
         }
-        transformCalleeReference(transformer, data)
         transformRValue(transformer, data)
         return this
     }
 
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        return this
+    }
+
     override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
         annotations.transformInplace(transformer, data)
         return this
@@ -89,22 +93,21 @@ internal class FirVariableAssignmentImpl(
         return this
     }
 
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
-        calleeReference = calleeReference.transformSingle(transformer, data)
-        return this
-    }
-
     override fun <D> transformRValue(transformer: FirTransformer<D>, data: D): FirVariableAssignmentImpl {
         rValue = rValue.transformSingle(transformer, data)
         return this
     }
 
+    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+        calleeReference = newCalleeReference
+    }
+
     override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>) {
         typeArguments.clear()
         typeArguments.addAll(newTypeArguments)
     }
 
-    override fun replaceCalleeReference(newCalleeReference: FirReference) {
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
-        calleeReference = newCalleeReference
+        explicitReceiver = newExplicitReceiver
     }
 }

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

@@ -74,7 +74,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
 import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
 import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
@@ -414,10 +413,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(whenBranch, data)
     }
 
-    open fun transformQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(qualifiedAccessWithoutCallee, data)
-    }
-
     open fun transformQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult<FirStatement> {
         return transformElement(qualifiedAccess, data)
     }
@@ -918,10 +913,6 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformWhenBranch(whenBranch, data)
     }
 
-    final override fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee, data)
-    }
-
     final override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): CompositeTransformResult<FirStatement> {
         return transformQualifiedAccess(qualifiedAccess, data)
     }

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

@@ -74,7 +74,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
 import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
 import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
@@ -276,8 +275,6 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitWhenBranch(whenBranch: FirWhenBranch, data: D): R  = visitElement(whenBranch, data)
 
-    open fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: D): R  = visitElement(qualifiedAccessWithoutCallee, data)
-
     open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: D): R  = visitElement(qualifiedAccess, data)
 
     open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): R  = visitElement(checkNotNullCall, data)

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

@@ -74,7 +74,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
 import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
 import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
@@ -412,10 +411,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(whenBranch)
     }
 
-    open fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee) {
-        visitElement(qualifiedAccessWithoutCallee)
-    }
-
     open fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess) {
         visitElement(qualifiedAccess)
     }
@@ -916,10 +911,6 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitWhenBranch(whenBranch)
     }
 
-    final override fun visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee: FirQualifiedAccessWithoutCallee, data: Nothing?) {
-        visitQualifiedAccessWithoutCallee(qualifiedAccessWithoutCallee)
-    }
-
     final override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: Nothing?) {
         visitQualifiedAccess(qualifiedAccess)
     }

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

@@ -78,5 +78,9 @@ internal class FirExpressionWithSmartcastImpl(
         throw IllegalStateException()
     }
 
+    override fun replaceExplicitReceiver(newExplicitReceiver: FirExpression?) {
+        throw IllegalStateException()
+    }
+
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 }

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

@@ -24,7 +24,7 @@ object FieldSets {
     val calleeReference = field("calleeReference", reference, withReplace = true)
 
     val receivers = fieldSet(
-        field("explicitReceiver", expression, nullable = true).withTransform(),
+        field("explicitReceiver", expression, nullable = true, withReplace = true).withTransform(),
         field("dispatchReceiver", expression).withTransform(),
         field("extensionReceiver", expression).withTransform()
     )
@@ -83,4 +83,4 @@ object FieldSets {
     val modality = field(modalityType, nullable = true)
 
     val scopeProvider = field("scopeProvider", firScopeProviderType)
-}
+}

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

@@ -90,8 +90,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val equalityOperatorCall = element("EqualityOperatorCall", Expression, expression, call)
     val whenExpression = element("WhenExpression", Expression, expression, resolvable)
     val whenBranch = element("WhenBranch", Expression)
-    val qualifiedAccessWithoutCallee = element("QualifiedAccessWithoutCallee", Expression, statement)
+    val qualifiedAccess = element("QualifiedAccess", Expression, resolvable, statement)
-    val qualifiedAccess = element("QualifiedAccess", Expression, qualifiedAccessWithoutCallee, resolvable)
     val checkNotNullCall = element("CheckNotNullCall", Expression, expression, call, resolvable)
     val elvisExpression = element("ElvisExpression", Expression, expression, resolvable)
 

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

@@ -74,11 +74,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
 
         impl(arrayOfCall)
 
-        val modifiableQualifiedAccess = impl(qualifiedAccessWithoutCallee, "FirModifiableQualifiedAccess") {}
+        impl(callableReferenceAccess)
-
-        impl(callableReferenceAccess) {
-            parents += modifiableQualifiedAccess
-        }
 
         impl(componentCall) {
             default("calleeReference", "FirSimpleNamedReference(source, Name.identifier(\"component\$componentIndex\"), null)")
@@ -128,14 +124,10 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         }
 
         impl(functionCall) {
-            parents += modifiableQualifiedAccess
             kind = OpenClass
         }
 
-        impl(qualifiedAccessExpression) {
+        impl(qualifiedAccessExpression)
-            parents += modifiableQualifiedAccess
-        }
-
 
         noImpl(expressionWithSmartcast)
 
@@ -269,7 +261,6 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         }
 
         impl(thisReceiverExpression) {
-            parents += modifiableQualifiedAccess
             defaultNoReceivers()
         }
 
@@ -280,8 +271,6 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         }
 
         impl(variableAssignment) {
-            parents += modifiableQualifiedAccess
-
             default("lValue") {
                 value = "calleeReference"
                 customSetter = "calleeReference = value"

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

@@ -12,7 +12,6 @@ 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
-import org.jetbrains.kotlin.fir.tree.generator.FieldSets.effectiveVisibility
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.initializer
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.modality
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.name
@@ -192,7 +191,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +field("rhs", expression).withTransform()
         }
 
-        qualifiedAccessWithoutCallee.configure {
+        qualifiedAccess.configure {
             +typeArguments.withTransform()
             +receivers
         }
@@ -354,6 +353,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         delegatedConstructorCall.configure {
             +field("constructedTypeRef", typeRef, withReplace = true)
             +field("dispatchReceiver", expression).withTransform()
+            +field("calleeReference", reference, withReplace = true)
             generateBooleanFields("this", "super")
         }
 

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

@@ -33,6 +33,7 @@ interface AbstractElement : FieldContainer, KindOwner {
     val defaultImplementation: Implementation?
     val customImplementations: List<Implementation>
     val overridenFields: Map<Field, Map<Importable, Boolean>>
+    val useNullableForReplace: Set<Field>
 
     override val allParents: List<KindOwner> get() = parents
 }
@@ -63,6 +64,7 @@ class Element(val name: String, kind: Kind) : AbstractElement {
 
     override val needTransformOtherChildren: Boolean get() = _needTransformOtherChildren || parents.any { it.needTransformOtherChildren }
     override val overridenFields: MutableMap<Field, MutableMap<Importable, Boolean>> = mutableMapOf()
+    override val useNullableForReplace: MutableSet<Field> = mutableSetOf()
     override val allImplementations: List<Implementation> by lazy {
         if (doesNotNeedImplementation) {
             emptyList()
@@ -90,6 +92,9 @@ class Element(val name: String, kind: Kind) : AbstractElement {
                     overridenFields[existingField, parentField] = false
                 } else {
                     overridenFields[existingField, parentField] = true
+                    if (parentField.nullable != existingField.nullable) {
+                        existingField.useNullableForReplace = true
+                    }
                 }
             } else {
                 overridenFields[parentField, parentField] = true
@@ -174,4 +179,4 @@ class TypeArgumentWithMultipleUpperBounds(name: String, override val upperBounds
     }
 }
 
-data class ArbitraryImportable(override val packageName: String, override val type: String) : Importable
+data class ArbitraryImportable(override val packageName: String, override val type: String) : Importable

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

@@ -26,6 +26,7 @@ sealed class Field : Importable {
     open val fromDelegate: Boolean get() = false
 
     open val overridenTypes: MutableSet<Importable> = mutableSetOf()
+    open var useNullableForReplace: Boolean = false
 
     fun copy(): Field = internalCopy().also {
         updateFieldsInCopy(it)
@@ -39,6 +40,7 @@ sealed class Field : Importable {
             copy.needTransformInOtherChildren = needTransformInOtherChildren
             copy.isMutable = isMutable
             copy.overridenTypes += overridenTypes
+            copy.useNullableForReplace = useNullableForReplace
         }
         copy.fromParent = fromParent
     }
@@ -98,6 +100,10 @@ class FieldWithDefault(val origin: Field) : Field() {
     override val overridenTypes: MutableSet<Importable>
         get() = origin.overridenTypes
 
+    override var useNullableForReplace: Boolean
+        get() = origin.useNullableForReplace
+        set(_) {}
+
     override fun internalCopy(): Field {
         return FieldWithDefault(origin).also {
             it.defaultValueInImplementation = defaultValueInImplementation

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

@@ -84,15 +84,15 @@ fun SmartPrinter.printElement(element: Element) {
             override()
             println("fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visit$name(this, data)")
 
-            fun Field.replaceDeclaration(override: Boolean, overridenType: Importable? = null) {
+            fun Field.replaceDeclaration(override: Boolean, overridenType: Importable? = null, forceNullable: Boolean = false) {
                 println()
                 abstract()
                 if (override) print("override ")
-                println(replaceFunctionDeclaration(overridenType))
+                println(replaceFunctionDeclaration(overridenType, forceNullable))
             }
 
             allFields.filter { it.withReplace }.forEach {
-                it.replaceDeclaration(overridenFields[it, it])
+                it.replaceDeclaration(overridenFields[it, it], forceNullable = it.useNullableForReplace)
                 for (overridenType in it.overridenTypes) {
                     it.replaceDeclaration(true, overridenType)
                 }

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

@@ -303,10 +303,15 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                 }
             }
 
-            fun generateReplace(field: Field, overridenType: Importable? = null, body: () -> Unit) {
+            fun generateReplace(
+                field: Field,
+                overridenType: Importable? = null,
+                forceNullable: Boolean = false,
+                body: () -> Unit,
+            ) {
                 println()
                 abstract()
-                print("override ${field.replaceFunctionDeclaration(overridenType)}")
+                print("override ${field.replaceFunctionDeclaration(overridenType, forceNullable)}")
                 if (isInterface || isAbstract) {
                     println()
                     return
@@ -326,7 +331,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
             for (field in allFields.filter { it.withReplace }) {
                 val capitalizedFieldName = field.name.capitalize()
                 val newValue = "new$capitalizedFieldName"
-                generateReplace(field) {
+                generateReplace(field, forceNullable = field.useNullableForReplace) {
                     when {
                         field.withGetter -> {}
 
@@ -336,6 +341,9 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                         }
 
                         else -> {
+                            if (field.useNullableForReplace) {
+                                println("require($newValue != null)")
+                            }
                             println("${field.name} = $newValue")
                         }
                     }

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

@@ -96,10 +96,13 @@ fun transformFunctionDeclaration(transformName: String, returnType: String): Str
     return "fun <D> transform$transformName(transformer: FirTransformer<D>, data: D): $returnType"
 }
 
-fun Field.replaceFunctionDeclaration(overridenType: Importable? = null): String {
+fun Field.replaceFunctionDeclaration(overridenType: Importable? = null, forceNullable: Boolean = false): String {
     val capName = name.capitalize()
     val type = overridenType?.typeWithArguments ?: typeWithArguments
-    return "fun replace$capName(new$capName: $type)"
+
+    val typeWithNullable = if (forceNullable && !type.endsWith("?")) "$type?" else type
+
+    return "fun replace$capName(new$capName: $typeWithNullable)"
 }
 
 val Field.mutableType: String