Optimization: make FIR expression an abstract class

NB: this commit does significant fir:tree refactoring.
It provides some boost due to faster abstract class dispatching in JVM.

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -474,7 +474,7 @@ internal fun generateTemporaryVariable(
     session: FirSession, psi: PsiElement?, specialName: String, initializer: FirExpression
 ): FirVariable = generateTemporaryVariable(session, psi, Name.special("<$specialName>"), initializer)
 
-private fun FirModifiableQualifiedAccess.initializeLValue(
+private fun FirModifiableQualifiedAccess<*>.initializeLValue(
     session: FirSession,
     left: KtExpression?,
     convertQualified: KtQualifiedExpression.() -> FirQualifiedAccess?

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

@@ -314,7 +314,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             }
         }
 
-        private fun KtCallElement.extractArgumentsTo(container: FirAbstractCall) {
+        private fun KtCallElement.extractArgumentsTo(container: FirCallWithArgumentList) {
             for (argument in this.valueArguments) {
                 val argumentExpression = argument.toFirExpression()
                 container.arguments += when (argument) {
@@ -1124,7 +1124,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             }
         }
 
-        private fun FirAbstractLoopJump.bindLabel(expression: KtExpressionWithLabel): FirAbstractLoopJump {
+        private fun FirLoopJump.bindLabel(expression: KtExpressionWithLabel): FirLoopJump {
             val labelName = expression.getLabelName()
             target = FirLoopTarget(labelName)
             val lastLoop = firLoops.lastOrNull()
@@ -1301,7 +1301,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
             val selector = expression.selectorExpression
                 ?: return FirErrorExpressionImpl(session, expression, "Qualified expression without selector")
             val firSelector = selector.toFirExpression("Incorrect selector expression")
-            if (firSelector is FirModifiableQualifiedAccess) {
+            if (firSelector is FirModifiableQualifiedAccess<*>) {
                 firSelector.safe = expression is KtSafeQualifiedExpression
                 firSelector.explicitReceiver = expression.receiverExpression.toFirExpression("Incorrect receiver expression")
             }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
+import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump
 import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
@@ -587,8 +588,8 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         whileLoop.block.accept(this)
     }
 
-    private fun visitLoopJump(jump: FirJump<FirLoop>) {
-        val target = jump.target
+    override fun visitLoopJump(loopJump: FirLoopJump) {
+        val target = loopJump.target
         val labeledElement = target.labeledElement
         print("@@@[")
         labeledElement.condition.accept(this)

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

@@ -5,14 +5,19 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirLabeledElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, FirTypedDeclaration, FirLabeledElement {
-    val receiverTypeRef: FirTypeRef?
+abstract class FirAnonymousFunction(
+    session: FirSession,
+    psi: PsiElement?
+) : @VisitedSupertype FirFunction, FirUnknownTypeExpression(session, psi), FirTypedDeclaration, FirLabeledElement {
+    abstract val receiverTypeRef: FirTypeRef?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitAnonymousFunction(this, data)

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

@@ -5,12 +5,18 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirAnonymousObject : @VisitedSupertype FirClass, FirExpression {
+abstract class FirAnonymousObject(
+    session: FirSession,
+    psi: PsiElement?
+) : @VisitedSupertype FirClass, FirUnknownTypeExpression(session, psi) {
     override val classKind: ClassKind
         get() = ClassKind.OBJECT
 
@@ -19,6 +25,6 @@ interface FirAnonymousObject : @VisitedSupertype FirClass, FirExpression {
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         super<FirClass>.acceptChildren(visitor, data)
-        super<FirExpression>.acceptChildren(visitor, data)
+        super<FirUnknownTypeExpression>.acceptChildren(visitor, data)
     }
 }

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

@@ -5,13 +5,18 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.BaseTransformedType
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirEnumEntry : @VisitedSupertype FirRegularClass, FirCall {
+abstract class FirEnumEntry(
+    session: FirSession,
+    psi: PsiElement?
+) : @VisitedSupertype FirRegularClass, FirCall(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitEnumEntry(this, data)
 

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

@@ -6,13 +6,11 @@
 package org.jetbrains.kotlin.fir.declarations.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirAnonymousFunctionImpl(
@@ -20,21 +18,21 @@ class FirAnonymousFunctionImpl(
     psi: PsiElement?,
     override var returnTypeRef: FirTypeRef,
     override var receiverTypeRef: FirTypeRef?
-) : FirAbstractFunction(session, psi), FirAnonymousFunction, FirModifiableFunction {
-    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
-
+) : FirAnonymousFunction(session, psi), FirModifiableFunction {
     override var label: FirLabel? = null
 
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
-        typeRef = newTypeRef
-    }
+    override val valueParameters = mutableListOf<FirValueParameter>()
+
+    override var body: FirBlock? = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
         returnTypeRef = returnTypeRef.transformSingle(transformer, data)
         receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
         label = label?.transformSingle(transformer, data)
-        return super<FirAbstractFunction>.transformChildren(transformer, data)
+        valueParameters.transformInplace(transformer, data)
+        body = body?.transformSingle(transformer, data)
+
+        return super<FirAnonymousFunction>.transformChildren(transformer, data)
     }
 
     override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D) {

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

@@ -11,35 +11,26 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class FirAnonymousObjectImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractAnnotatedDeclaration(session, psi), FirAnonymousObject, FirModifiableClass {
-    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
-
+) : FirAnonymousObject(session, psi), FirModifiableClass {
     override val superTypeRefs = mutableListOf<FirTypeRef>()
 
     override val declarations = mutableListOf<FirDeclaration>()
 
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
-        typeRef = newTypeRef
-    }
-
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
         return super<FirAnonymousObject>.accept(visitor, data)
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
         superTypeRefs.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
 
-        return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)
+        return super<FirAnonymousObject>.transformChildren(transformer, data)
     }
 }

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

@@ -10,8 +10,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -21,40 +20,63 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitEnumTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 class FirEnumEntryImpl(
     session: FirSession,
     psi: PsiElement?,
-    symbol: FirClassSymbol,
-    name: Name
-) : FirClassImpl(
-    session,
-    psi,
-    symbol,
-    name,
-    visibility = Visibilities.UNKNOWN,
-    modality = Modality.FINAL,
-    isExpect = false,
-    isActual = false,
-    classKind = ClassKind.ENUM_ENTRY,
-    isInner = false,
-    isCompanion = false,
-    isData = false,
-    isInline = false
-), FirEnumEntry {
+    override val symbol: FirClassSymbol,
+    override val name: Name
+) : FirEnumEntry(session, psi), FirModifiableClass {
+    init {
+        symbol.bind(this)
+    }
+
+    override var status = FirDeclarationStatusImpl(session, Visibilities.UNKNOWN, Modality.FINAL)
+
+    override val classKind: ClassKind
+        get() = ClassKind.ENUM_ENTRY
+
+    override val typeParameters = mutableListOf<FirTypeParameter>()
+
+    override val superTypeRefs = mutableListOf<FirTypeRef>()
+
+    override val declarations = mutableListOf<FirDeclaration>()
+
+    override val companionObject: FirRegularClass?
+        get() = null
+
     override var typeRef: FirTypeRef = FirImplicitEnumTypeRef(session, null)
 
     override val arguments = mutableListOf<FirExpression>()
 
+    override fun replaceSupertypes(newSupertypes: List<FirTypeRef>): FirRegularClass {
+        superTypeRefs.clear()
+        superTypeRefs.addAll(newSupertypes)
+        return this
+    }
+
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
         typeRef = newTypeRef
     }
 
+    fun addDeclaration(declaration: FirDeclaration) {
+        declarations += declaration
+    }
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClass {
+        superTypeRefs.transformInplace(transformer, data)
+        typeParameters.transformInplace(transformer, data)
+        status = status.transformSingle(transformer, data)
+
+        declarations.firstIsInstanceOrNull<FirConstructorImpl>()?.typeParameters?.transformInplace(transformer, data)
+        // Transform declarations in last turn
+        declarations.transformInplace(transformer, data)
+
         typeRef = typeRef.transformSingle(transformer, data)
         arguments.transformInplace(transformer, data)
 
-        return super<FirClassImpl>.transformChildren(transformer, data)
+        return super<FirEnumEntry>.transformChildren(transformer, data) as FirRegularClass
     }
 
     override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCall {

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

@@ -5,8 +5,10 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-import org.jetbrains.kotlin.fir.BaseTransformedType
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -14,12 +16,14 @@ import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.name.FqName
 
-@BaseTransformedType
-interface FirAnnotationCall : FirCall {
-    val annotationTypeRef: FirTypeRef
+abstract class FirAnnotationCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeCallWithArgumentList(session, psi) {
+    abstract val annotationTypeRef: FirTypeRef
 
     // May be should be not-null (with correct default target)
-    val useSiteTarget: AnnotationUseSiteTarget?
+    abstract val useSiteTarget: AnnotationUseSiteTarget?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitAnnotationCall(this, data)

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirArrayOfCall : FirCall {
+abstract class FirArrayOfCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeCallWithArgumentList(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitArrayOfCall(this, data)
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt

@@ -5,12 +5,17 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirArraySetCall : @VisitedSupertype FirCall, FirAssignment {
+abstract class FirArraySetCall(
+    session: FirSession,
+    psi: PsiElement?
+) : @VisitedSupertype FirCall(session, psi), FirAssignment {
     // NB: arguments of this thing are indexes AND rvalue
-    val indexes: List<FirExpression>
+    abstract val indexes: List<FirExpression>
 
     override val arguments get() = indexes + rValue
 
@@ -18,11 +23,8 @@ interface FirArraySetCall : @VisitedSupertype FirCall, FirAssignment {
         visitor.visitArraySetCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        for (index in indexes) {
-            index.accept(visitor, data)
-        }
-        acceptAnnotations(visitor, data)
-        typeRef.accept(visitor, data)
-        super<FirAssignment>.acceptChildren(visitor, data)
+        super<FirCall>.acceptChildren(visitor, data)
+        calleeReference.accept(visitor, data)
+        rValue.accept(visitor, data)
     }
 }

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

@@ -5,10 +5,16 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirBlock : FirExpression {
-    val statements: List<FirStatement>
+abstract class FirBlock(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val statements: List<FirStatement>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitBlock(this, data)

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirBreakExpression : FirJump<FirLoop> {
+abstract class FirBreakExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirLoopJump(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitBreakExpression(this, data)
 }

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

@@ -5,13 +5,18 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.BaseTransformedType
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirCall : FirExpression {
-    val arguments: List<FirExpression>
+abstract class FirCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirExpression(session, psi) {
+    abstract val arguments: List<FirExpression>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitCall(this, data)
@@ -23,5 +28,5 @@ interface FirCall : FirExpression {
         super.acceptChildren(visitor, data)
     }
 
-    fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCall
+    abstract fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCall
 }

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

@@ -5,9 +5,14 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirCallableReferenceAccess : FirQualifiedAccessExpression {
+abstract class FirCallableReferenceAccess(
+    session: FirSession,
+    psi: PsiElement?
+) : FirQualifiedAccessExpression(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitCallableReferenceAccess(this, data)
 }

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

@@ -5,11 +5,17 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirClassReferenceExpression : FirExpression {
-    val classTypeRef: FirTypeRef
+abstract class FirClassReferenceExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val classTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitClassReferenceExpression(this, data)

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

@@ -5,12 +5,19 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 
-interface FirConstExpression<T> : FirExpression {
-    val kind: IrConstKind<T>
-    val value: T
+abstract class FirConstExpression<T>(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val kind: IrConstKind<T>
+
+    abstract val value: T
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
         return visitor.visitConstExpression(this, data)

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirLoopJump
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirContinueExpression : FirJump<FirLoop> {
+abstract class FirContinueExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirLoopJump(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitContinueExpression(this, data)
 }

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

@@ -5,15 +5,21 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirDelegatedConstructorCall : @VisitedSupertype FirCall, FirQualifiedAccess {
+abstract class FirDelegatedConstructorCall(
+    session: FirSession,
+    psi: PsiElement?
+) : @VisitedSupertype FirCallWithArgumentList(session, psi), FirQualifiedAccess {
     // Do we need 'constructedType: FirType' here?
-    val constructedTypeRef: FirTypeRef
+    abstract val constructedTypeRef: FirTypeRef
 
-    val isThis: Boolean
+    abstract val isThis: Boolean
 
     val isSuper: Boolean
         get() = !isThis
@@ -24,6 +30,6 @@ interface FirDelegatedConstructorCall : @VisitedSupertype FirCall, FirQualifiedA
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         constructedTypeRef.accept(visitor, data)
         calleeReference.accept(visitor, data)
-        super<FirCall>.acceptChildren(visitor, data)
+        super<FirCallWithArgumentList>.acceptChildren(visitor, data)
     }
 }

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

@@ -5,10 +5,16 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirErrorExpression : FirExpression {
-    val reason: String
+abstract class FirErrorExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val reason: String
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
         return visitor.visitErrorExpression(this, data)

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

@@ -5,15 +5,21 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirResolvedCallableReference
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotatedStatement
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirExpression : FirStatement {
-    val typeRef: FirTypeRef
+abstract class FirExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAnnotatedStatement(session, psi) {
+    abstract val typeRef: FirTypeRef
 
-    fun replaceTypeRef(newTypeRef: FirTypeRef)
+    abstract fun replaceTypeRef(newTypeRef: FirTypeRef)
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitExpression(this, data)

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

@@ -9,27 +9,25 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirNamedReference
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractCall
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
 import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 abstract class FirFunctionCall(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractCall(session, psi), @VisitedSupertype FirCall, FirQualifiedAccess, FirTypeProjectionContainer {
+) : @VisitedSupertype FirUnknownTypeCallWithArgumentList(session, psi), FirQualifiedAccess, FirTypeProjectionContainer {
     abstract override val calleeReference: FirNamedReference
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitFunctionCall(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        for (argument in arguments) {
-            argument.accept(visitor, data)
-        }
+        calleeReference.accept(visitor, data)
+        explicitReceiver?.accept(visitor, data)
         for (typeArgument in typeArguments) {
             typeArgument.accept(visitor, data)
         }
-        typeRef.accept(visitor, data)
-        super<FirQualifiedAccess>.acceptChildren(visitor, data)
+        super<FirUnknownTypeCallWithArgumentList>.acceptChildren(visitor, data)
     }
 }

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirGetClassCall : FirCall {
+abstract class FirGetClassCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeCallWithArgumentList(session, psi) {
     val argument: FirExpression get() = arguments.first()
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =

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

@@ -5,12 +5,17 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirTarget
 import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirJump<E : FirTargetElement> : FirExpression {
-    val target: FirTarget<E>
+abstract class FirJump<E : FirTargetElement>(
+    session: FirSession,
+    psi: PsiElement?
+) : FirExpression(session, psi) {
+    abstract val target: FirTarget<E>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitJump(this, data)

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

@@ -5,10 +5,16 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirOperatorCall : FirCall {
-    val operation: FirOperation
+abstract class FirOperatorCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirCallWithArgumentList(session, psi) {
+    abstract val operation: FirOperation
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitOperatorCall(this, data)

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

@@ -5,15 +5,22 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirQualifiedAccessExpression : @VisitedSupertype FirQualifiedAccess, FirExpression {
+abstract class FirQualifiedAccessExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirQualifiedAccess, @VisitedSupertype FirUnknownTypeExpression(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitQualifiedAccessExpression(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        super<FirQualifiedAccess>.acceptChildren(visitor, data)
-        typeRef.accept(visitor, data)
+        calleeReference.accept(visitor, data)
+        explicitReceiver?.accept(visitor, data)
+        super<FirUnknownTypeExpression>.acceptChildren(visitor, data)
     }
 }

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

@@ -5,16 +5,23 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
-interface FirResolvedQualifier : FirExpression {
+abstract class FirResolvedQualifier(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val packageFqName: FqName
+
+    abstract val relativeClassFqName: FqName?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedQualifier(this, data)
 
-    val packageFqName: FqName
-    val relativeClassFqName: FqName?
     val classId
         get() = relativeClassFqName?.let {
             ClassId(packageFqName, it, false)

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

@@ -5,11 +5,16 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirReturnExpression : FirJump<FirFunction> {
-    val result: FirExpression
+abstract class FirReturnExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirJump<FirFunction>(session, psi) {
+    abstract val result: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitReturnExpression(this, data)

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

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirCallWithArgumentList
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirStringConcatenationCall : FirCall {
+abstract class FirStringConcatenationCall(
+    session: FirSession,
+    psi: PsiElement?
+) : FirCallWithArgumentList(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitStringConcatenationCall(this, data)
 }

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

@@ -5,10 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirThrowExpression : FirExpression {
-    val exception: FirExpression
+abstract class FirThrowExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirExpression(session, psi) {
+    abstract val exception: FirExpression
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitThrowExpression(this, data)

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

@@ -5,14 +5,20 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirTryExpression : FirExpression {
-    val tryBlock: FirBlock
+abstract class FirTryExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val tryBlock: FirBlock
 
-    val catches: List<FirCatch>
+    abstract val catches: List<FirCatch>
 
-    val finallyBlock: FirBlock?
+    abstract val finallyBlock: FirBlock?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTryExpression(this, data)

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

@@ -5,14 +5,21 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirOperationBasedCall
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // is/!is/as/as?
-interface FirTypeOperatorCall : FirOperatorCall {
+abstract class FirTypeOperatorCall(
+    session: FirSession,
+    psi: PsiElement?,
+    operation: FirOperation
+) : FirOperationBasedCall(session, psi, operation) {
     val argument: FirExpression get() = arguments.first()
 
-    val conversionTypeRef: FirTypeRef
+    abstract val conversionTypeRef: FirTypeRef
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitTypeOperatorCall(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirUncheckedNotNullCast.kt

@@ -5,9 +5,15 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeCallWithArgumentList
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirUncheckedNotNullCast : FirCall {
+abstract class FirUncheckedNotNullCast(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeCallWithArgumentList(session, psi) {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitUncheckedNotNullCast(this, data)
 
     val expression: FirExpression get() = arguments[0]

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 

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

@@ -5,20 +5,25 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirWhenExpression : FirExpression {
-    val subject: FirExpression?
+abstract class FirWhenExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val subject: FirExpression?
 
     // when (val subjectVariable = subject()) { ... }
-    val subjectVariable: FirVariable?
+    abstract val subjectVariable: FirVariable?
 
-    val branches: List<FirWhenBranch>
+    abstract val branches: List<FirWhenBranch>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitWhenExpression(this, data)
 
-
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         subjectVariable?.accept(visitor, data) ?: subject?.accept(visitor, data)
         for (branch in branches) {

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

@@ -5,11 +5,17 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirWhenSubject
+import org.jetbrains.kotlin.fir.expressions.impl.FirUnknownTypeExpression
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-interface FirWhenSubjectExpression : FirExpression {
-    val whenSubject: FirWhenSubject
+abstract class FirWhenSubjectExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirUnknownTypeExpression(session, psi) {
+    abstract val whenSubject: FirWhenSubject
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitWhenSubjectExpression(this, data)

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

@@ -7,14 +7,13 @@ package org.jetbrains.kotlin.fir.expressions
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractStatement
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 abstract class FirWrappedArgumentExpression(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractStatement(session, psi), FirExpression {
+) : FirExpression(session, psi) {
     abstract val expression: FirExpression
 
     open val isSpread: Boolean
@@ -32,6 +31,6 @@ abstract class FirWrappedArgumentExpression(
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         expression.accept(visitor, data)
-        super<FirExpression>.acceptChildren(visitor, data)
+        super.acceptChildren(visitor, data)
     }
 }

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

@@ -16,7 +16,7 @@ abstract class FirAbstractLoop(
     session: FirSession,
     psi: PsiElement?,
     override var condition: FirExpression
-) : FirAbstractStatement(session, psi), FirLoop {
+) : FirAnnotatedStatement(session, psi), FirLoop {
     override lateinit var block: FirBlock
 
     override var label: FirLabel? = null
@@ -25,6 +25,6 @@ abstract class FirAbstractLoop(
         condition = condition.transformSingle(transformer, data)
         block = block.transformSingle(transformer, data)
         label = label?.transformSingle(transformer, data)
-        return super<FirAbstractStatement>.transformChildren(transformer, data)
+        return super<FirAnnotatedStatement>.transformChildren(transformer, data)
     }
 }

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

@@ -15,7 +15,7 @@ abstract class FirAbstractQualifiedAccess(
     session: FirSession,
     psi: PsiElement?,
     final override var safe: Boolean = false
-) : FirAbstractStatement(session, psi), FirModifiableQualifiedAccess {
+) : FirAnnotatedStatement(session, psi), FirModifiableQualifiedAccess<FirReference> {
     final override lateinit var calleeReference: FirReference
 
     final override var explicitReceiver: FirExpression? = null
@@ -23,7 +23,7 @@ abstract class FirAbstractQualifiedAccess(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         calleeReference = calleeReference.transformSingle(transformer, data)
         explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
-        return super<FirAbstractStatement>.transformChildren(transformer, data)
+        return super<FirAnnotatedStatement>.transformChildren(transformer, data)
     }
 
     override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccess {

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

@@ -9,7 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 
-abstract class FirAbstractStatement(
+abstract class FirAnnotatedStatement(
     session: FirSession,
     psi: PsiElement?
 ) : FirAbstractAnnotatedElement(session, psi), FirStatement

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

@@ -19,10 +19,10 @@ class FirAnnotationCallImpl(
     psi: PsiElement?,
     override val useSiteTarget: AnnotationUseSiteTarget?,
     override var annotationTypeRef: FirTypeRef
-) : FirAbstractCall(session, psi), FirAnnotationCall {
+) : FirAnnotationCall(session, psi) {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         annotationTypeRef = annotationTypeRef.transformSingle(transformer, data)
 
-        return super<FirAbstractCall>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -12,4 +12,4 @@ import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 class FirArrayOfCallImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractCall(session, psi), FirArrayOfCall
+) : FirArrayOfCall(session, psi)

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

@@ -6,22 +6,30 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
-import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class FirArraySetCallImpl(
     session: FirSession,
     psi: PsiElement?,
-    value: FirExpression,
-    operation: FirOperation
-) : FirAbstractAssignment(session, psi, value, operation, false), FirArraySetCall {
+    override var rValue: FirExpression,
+    override val operation: FirOperation
+) : FirArraySetCall(session, psi), FirModifiableQualifiedAccess<FirReference> {
+    override lateinit var calleeReference: FirReference
+
+    override var lValue: FirReference
+        get() = calleeReference
+        set(value) {
+            calleeReference = value
+        }
+
+    override var explicitReceiver: FirExpression?
+        get() = null
+        set(_) {}
+
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
 
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
@@ -30,14 +38,9 @@ class FirArraySetCallImpl(
 
     override val indexes = mutableListOf<FirExpression>()
 
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        super<FirArraySetCall>.accept(visitor, data)
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
-        indexes.transformInplace(transformer, data)
-
-        return super<FirAbstractAssignment>.transformChildren(transformer, data)
+    override fun <D> transformRValue(transformer: FirTransformer<D>, data: D): FirAssignment {
+        rValue = rValue.transformSingle(transformer, data)
+        return this
     }
 
     override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCall {
@@ -45,4 +48,13 @@ class FirArraySetCallImpl(
         indexes.transformInplace(transformer, data)
         return this
     }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        rValue = rValue.transformSingle(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
+        indexes.transformInplace(transformer, data)
+
+        return super<FirArraySetCall>.transformChildren(transformer, data)
+    }
 }

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

@@ -16,11 +16,11 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirBlockImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractBlock(session, psi), FirBlock {
+) : FirBlock(session, psi) {
     override val statements = mutableListOf<FirStatement>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         statements.transformInplace(transformer, data)
-        return super<FirAbstractBlock>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -12,4 +12,4 @@ import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
 class FirBreakExpressionImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractLoopJump(session, psi), FirBreakExpression
+) : FirBreakExpression(session, psi)

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

@@ -1,29 +1,32 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2019 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 com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractCall(
+abstract class FirCallWithArgumentList(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractExpression(session, psi), FirCall {
-    final override val arguments = mutableListOf<FirExpression>()
+) : FirCall(session, psi) {
+    override val arguments = mutableListOf<FirExpression>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         arguments.transformInplace(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 
     override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCall {
         arguments.transformInplace(transformer, data)
         return this
     }
+
 }

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

@@ -7,26 +7,25 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirReference
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirCallableReferenceAccessImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractQualifiedAccess(session, psi), FirCallableReferenceAccess {
-    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+) : FirCallableReferenceAccess(session, psi), FirModifiableQualifiedAccess<FirReference> {
+    override lateinit var calleeReference: FirReference
 
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
-        typeRef = newTypeRef
-    }
+    override var explicitReceiver: FirExpression? = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
 
-        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+        return super<FirCallableReferenceAccess>.transformChildren(transformer, data)
     }
 }

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

@@ -17,9 +17,9 @@ class FirClassReferenceExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     override var classTypeRef: FirTypeRef
-) : FirAbstractExpression(session, psi), FirClassReferenceExpression {
+) : FirClassReferenceExpression(session, psi) {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         classTypeRef = classTypeRef.transformSingle(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -15,7 +15,7 @@ class FirConstExpressionImpl<T>(
     psi: PsiElement?,
     override val kind: IrConstKind<T>,
     override val value: T
-) : FirAbstractExpression(session, psi), FirConstExpression<T>
+) : FirConstExpression<T>(session, psi)
 
 fun <T> FirConstExpressionImpl(session: FirSession, psi: PsiElement?, kind: IrConstKind<T>, value: T?, errorReason: String) =
     value?.let { FirConstExpressionImpl(session, psi, kind, it) } ?: FirErrorExpressionImpl(session, psi, errorReason)

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

@@ -12,4 +12,4 @@ import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
 class FirContinueExpressionImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractLoopJump(session, psi), FirContinueExpression
+) : FirContinueExpression(session, psi)

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

@@ -23,7 +23,7 @@ class FirDelegatedConstructorCallImpl(
     psi: PsiElement?,
     override var constructedTypeRef: FirTypeRef,
     override val isThis: Boolean
-) : FirAbstractCall(session, psi), FirDelegatedConstructorCall {
+) : FirDelegatedConstructorCall(session, psi) {
     override var calleeReference: FirReference =
         if (isThis) FirExplicitThisReference(session, psi, null) else FirExplicitSuperReference(session, psi, constructedTypeRef)
 
@@ -35,8 +35,9 @@ class FirDelegatedConstructorCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         constructedTypeRef = constructedTypeRef.transformSingle(transformer, data)
         calleeReference = calleeReference.transformSingle(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
 
-        return super<FirAbstractCall>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 
     override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess {
@@ -44,4 +45,6 @@ class FirDelegatedConstructorCallImpl(
     }
 
     override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 }

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

@@ -6,15 +6,26 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 // Representation of "dummy" condition at else branch
 class FirElseIfTrueCondition(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractExpression(session, psi) {
+) : FirExpression(session, psi) {
 
     override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
+    }
 }

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

@@ -11,6 +11,6 @@ import org.jetbrains.kotlin.fir.expressions.FirStatement
 
 class FirEmptyExpressionBlock(
     session: FirSession
-) : FirAbstractBlock(session, null), FirBlock {
+) : FirBlock(session, null) {
     override val statements: List<FirStatement> = listOf()
 }

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

@@ -13,4 +13,4 @@ class FirErrorExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     override val reason: String
-) : FirAbstractExpression(session, psi), FirErrorExpression
+) : FirErrorExpression(session, psi)

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

@@ -7,9 +7,8 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.expressions.FirExpression
 
 class FirExpressionStub(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractExpression(session, psi)
+) : FirUnknownTypeExpression(session, psi)

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
@@ -18,7 +17,7 @@ class FirFunctionCallImpl(
     session: FirSession,
     psi: PsiElement?,
     override var safe: Boolean = false
-) : FirFunctionCall(session, psi), FirModifiableQualifiedAccess {
+) : FirFunctionCall(session, psi), FirModifiableQualifiedAccess<FirNamedReference> {
     override val typeArguments = mutableListOf<FirTypeProjection>()
 
     override lateinit var calleeReference: FirNamedReference

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

@@ -12,4 +12,4 @@ import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 class FirGetClassCallImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractCall(session, psi), FirGetClassCall
+) : FirGetClassCall(session, psi)

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

@@ -6,18 +6,28 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirTarget
 import org.jetbrains.kotlin.fir.expressions.FirJump
 import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractLoopJump(
+abstract class FirLoopJump(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractExpression(session, psi), FirJump<FirLoop> {
+) : FirJump<FirLoop>(session, psi) {
     override lateinit var target: FirTarget<FirLoop>
 
     override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
+    }
 }

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

@@ -5,15 +5,28 @@
 
 package org.jetbrains.kotlin.fir.expressions.impl
 
+import org.jetbrains.kotlin.fir.FirReference
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+interface FirModifiableQualifiedAccess<C : FirReference> : FirQualifiedAccess {
+    override var calleeReference: C
 
-interface FirModifiableQualifiedAccess : FirQualifiedAccess {
     override var safe: Boolean
-        get() = super.safe
+        get() = false
         set(_) {}
 
     override var explicitReceiver: FirExpression?
-        get() = super.explicitReceiver
-        set(_) {}
+
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirQualifiedAccess {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        return this
+    }
+
+    override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirQualifiedAccess {
+        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
+        return this
+    }
 }

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

@@ -6,20 +6,33 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirOperation
+import org.jetbrains.kotlin.fir.expressions.FirOperatorCall
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitBooleanTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractOperationBasedCall(
+abstract class FirOperationBasedCall(
     session: FirSession,
     psi: PsiElement?,
-    val operation: FirOperation
-) : FirAbstractCall(session, psi) {
+    final override val operation: FirOperation
+) : FirOperatorCall(session, psi) {
     override var typeRef: FirTypeRef = if (operation in FirOperation.BOOLEANS) {
         FirImplicitBooleanTypeRef(session, null)
     } else {
         FirImplicitTypeRefImpl(session, null)
     }
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
+    }
 }

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

@@ -8,10 +8,9 @@ package org.jetbrains.kotlin.fir.expressions.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirOperation
-import org.jetbrains.kotlin.fir.expressions.FirOperatorCall
 
 class FirOperatorCallImpl(
     session: FirSession,
     psi: PsiElement?,
     operation: FirOperation
-) : FirAbstractOperationBasedCall(session, psi, operation), FirOperatorCall
+) : FirOperationBasedCall(session, psi, operation)

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

@@ -7,27 +7,26 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirReference
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirQualifiedAccessExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
-    safe: Boolean = false
-) : FirAbstractQualifiedAccess(session, psi, safe), FirQualifiedAccessExpression {
-    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+    override var safe: Boolean = false
+) : FirModifiableQualifiedAccess<FirReference>, FirQualifiedAccessExpression(session, psi) {
+    override lateinit var calleeReference: FirReference
 
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
-        typeRef = newTypeRef
-    }
+    override var explicitReceiver: FirExpression? = null
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
 
-        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+        return super<FirQualifiedAccessExpression>.transformChildren(transformer, data)
     }
 }

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

@@ -16,7 +16,7 @@ class FirResolvedQualifierImpl(
     psi: PsiElement?,
     override val packageFqName: FqName,
     override val relativeClassFqName: FqName?
-) : FirResolvedQualifier, FirAbstractExpression(session, psi) {
+) : FirResolvedQualifier(session, psi) {
     constructor(session: FirSession, psi: PsiElement?, classId: ClassId) : this(
         session,
         psi,

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

@@ -12,20 +12,22 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitNothingTypeRef
-import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirReturnExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     override var result: FirExpression
-) : FirAbstractExpression(session, psi), FirReturnExpression {
+) : FirReturnExpression(session, psi) {
     override lateinit var target: FirTarget<FirFunction>
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         result = result.transformSingle(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 
     override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
 }

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

@@ -15,12 +15,12 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirSingleExpressionBlock(
     session: FirSession,
     private var statement: FirStatement
-) : FirAbstractBlock(session, statement.psi), FirBlock {
+) : FirBlock(session, statement.psi) {
     override val statements
         get() = listOf(statement)
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         statement = statement.transformSingle(transformer, data)
-        return super<FirAbstractBlock>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -6,14 +6,24 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitStringTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirStringConcatenationCallImpl(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractCall(session, psi), FirStringConcatenationCall {
+) : FirStringConcatenationCall(session, psi) {
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
     override var typeRef: FirTypeRef = FirImplicitStringTypeRef(session, psi)
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
+    }
 }

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirAbstractElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
@@ -20,10 +19,13 @@ class FirThrowExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     override var exception: FirExpression
-) : FirAbstractExpression(session, psi), FirThrowExpression {
+) : FirThrowExpression(session, psi) {
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         exception = exception.transformSingle(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 
     override var typeRef: FirTypeRef = FirImplicitNothingTypeRef(session, psi)

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

@@ -6,10 +6,13 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirCatch
 import org.jetbrains.kotlin.fir.expressions.FirTryExpression
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirTryExpressionImpl(
@@ -17,13 +20,13 @@ class FirTryExpressionImpl(
     psi: PsiElement?,
     override var tryBlock: FirBlock,
     override var finallyBlock: FirBlock?
-) : FirAbstractExpression(session, psi), FirTryExpression {
+) : FirTryExpression(session, psi) {
     override val catches = mutableListOf<FirCatch>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         tryBlock = tryBlock.transformSingle(transformer, data)
         finallyBlock = finallyBlock?.transformSingle(transformer, data)
         catches.transformInplace(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -19,9 +19,9 @@ class FirTypeOperatorCallImpl(
     psi: PsiElement?,
     operation: FirOperation,
     override var conversionTypeRef: FirTypeRef
-) : FirAbstractOperationBasedCall(session, psi, operation), FirTypeOperatorCall {
+) : FirTypeOperatorCall(session, psi, operation) {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         conversionTypeRef = conversionTypeRef.transformSingle(transformer, data)
-        return super<FirAbstractOperationBasedCall>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -9,14 +9,12 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirUncheckedNotNullCast
-import org.jetbrains.kotlin.fir.expressions.FirOperation
-import org.jetbrains.kotlin.fir.types.FirTypeRef
 
 class FirUncheckedNotNullCastImpl(
     session: FirSession,
     psi: PsiElement?,
     expression: FirExpression
-) : FirAbstractCall(session, psi), FirUncheckedNotNullCast {
+) : FirUncheckedNotNullCast(session, psi) {
     init {
         arguments += expression
     }

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

@@ -6,13 +6,24 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirUnitExpression(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractExpression(session, psi) {
+) : FirExpression(session, psi) {
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {}
+
     override var typeRef: FirTypeRef = FirImplicitUnitTypeRef(session, psi)
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+        return super.transformChildren(transformer, data)
+    }
 }

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

@@ -8,16 +8,15 @@ package org.jetbrains.kotlin.fir.expressions.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractBlock(
+abstract class FirUnknownTypeCallWithArgumentList(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractAnnotatedElement(session, psi), FirBlock {
+) : FirCallWithArgumentList(session, psi) {
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
 
     override fun replaceTypeRef(newTypeRef: FirTypeRef) {
@@ -27,6 +26,6 @@ abstract class FirAbstractBlock(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         typeRef = typeRef.transformSingle(transformer, data)
 
-        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -10,24 +10,23 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.transformSingle
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-abstract class FirAbstractExpression(
+abstract class FirUnknownTypeExpression(
     session: FirSession,
     psi: PsiElement?
-) : FirAbstractStatement(session, psi), FirExpression {
-    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+) : FirExpression(session, psi) {
+    final override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
 
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+    final override fun replaceTypeRef(newTypeRef: FirTypeRef) {
         typeRef = newTypeRef
     }
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         typeRef = typeRef.transformSingle(transformer, data)
 
-        return super<FirAbstractStatement>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -18,7 +18,7 @@ class FirWhenExpressionImpl(
     psiElement: PsiElement?,
     override var subject: FirExpression? = null,
     override var subjectVariable: FirVariable? = null
-) : FirAbstractExpression(session, psiElement), FirWhenExpression {
+) : FirWhenExpression(session, psiElement) {
     override val branches = mutableListOf<FirWhenBranch>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
@@ -28,6 +28,6 @@ class FirWhenExpressionImpl(
             subject = subject?.transformSingle(transformer, data)
         }
         branches.transformInplace(transformer, data)
-        return super<FirAbstractExpression>.transformChildren(transformer, data)
+        return super.transformChildren(transformer, data)
     }
 }

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

@@ -14,4 +14,4 @@ class FirWhenSubjectExpressionImpl(
     session: FirSession,
     psi: PsiElement?,
     override val whenSubject: FirWhenSubject
-) : FirAbstractExpression(session, psi), FirWhenSubjectExpression
+) : FirWhenSubjectExpression(session, psi)

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt

@@ -172,52 +172,60 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(statement, data)
     }
 
-    open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(klass, data)
-    }
-
-    open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult<FirStatement> {
-        return transformClass(anonymousObject, data)
-    }
-
-    open fun transformModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult<FirStatement> {
-        return transformClass(modifiableClass, data)
-    }
-
-    open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(errorStatement, data)
+    open fun transformAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): CompositeTransformResult<FirStatement> {
+        return transformStatement(annotatedStatement, data)
     }
 
     open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformStatement(expression, data)
-    }
-
-    open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(block, data)
+        return transformAnnotatedStatement(expression, data)
     }
 
     open fun transformCall(call: FirCall, data: D): CompositeTransformResult<FirStatement> {
         return transformExpression(call, data)
     }
 
-    open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(annotationCall, data)
-    }
-
-    open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(arrayOfCall, data)
-    }
-
     open fun transformArraySetCall(arraySetCall: FirArraySetCall, data: D): CompositeTransformResult<FirStatement> {
         return transformCall(arraySetCall, data)
     }
 
+    open fun transformCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
+        return transformCall(callWithArgumentList, data)
+    }
+
     open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(delegatedConstructorCall, data)
+        return transformCallWithArgumentList(delegatedConstructorCall, data)
+    }
+
+    open fun transformOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformCallWithArgumentList(operatorCall, data)
+    }
+
+    open fun transformOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformOperatorCall(operationBasedCall, data)
+    }
+
+    open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformOperationBasedCall(typeOperatorCall, data)
+    }
+
+    open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformCallWithArgumentList(stringConcatenationCall, data)
+    }
+
+    open fun transformUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): CompositeTransformResult<FirStatement> {
+        return transformCallWithArgumentList(unknownTypeCallWithArgumentList, data)
+    }
+
+    open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeCallWithArgumentList(annotationCall, data)
+    }
+
+    open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeCallWithArgumentList(arrayOfCall, data)
     }
 
     open fun transformFunctionCall(functionCall: FirFunctionCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(functionCall, data)
+        return transformUnknownTypeCallWithArgumentList(functionCall, data)
     }
 
     open fun transformComponentCall(componentCall: FirComponentCall, data: D): CompositeTransformResult<FirStatement> {
@@ -225,71 +233,79 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
     }
 
     open fun transformGetClassCall(getClassCall: FirGetClassCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(getClassCall, data)
-    }
-
-    open fun transformOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(operatorCall, data)
-    }
-
-    open fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformOperatorCall(typeOperatorCall, data)
-    }
-
-    open fun transformStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(stringConcatenationCall, data)
+        return transformUnknownTypeCallWithArgumentList(getClassCall, data)
     }
 
     open fun transformUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): CompositeTransformResult<FirStatement> {
-        return transformCall(uncheckedNotNullCast, data)
-    }
-
-    open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(classReferenceExpression, data)
-    }
-
-    open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(constExpression, data)
-    }
-
-    open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(errorExpression, data)
+        return transformUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
     }
 
     open fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: D): CompositeTransformResult<FirStatement> {
         return transformExpression(jump, data)
     }
 
+    open fun transformLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult<FirStatement> {
+        return transformJump(loopJump, data)
+    }
+
     open fun transformBreakExpression(breakExpression: FirBreakExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformJump(breakExpression, data)
+        return transformLoopJump(breakExpression, data)
     }
 
     open fun transformContinueExpression(continueExpression: FirContinueExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformJump(continueExpression, data)
+        return transformLoopJump(continueExpression, data)
     }
 
     open fun transformReturnExpression(returnExpression: FirReturnExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformJump(returnExpression, data)
     }
 
-    open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(resolvedQualifier, data)
-    }
-
     open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult<FirStatement> {
         return transformExpression(throwExpression, data)
     }
 
+    open fun transformUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformExpression(unknownTypeExpression, data)
+    }
+
+    open fun transformBlock(block: FirBlock, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(block, data)
+    }
+
+    open fun transformClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(classReferenceExpression, data)
+    }
+
+    open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(constExpression, data)
+    }
+
+    open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(errorExpression, data)
+    }
+
+    open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(qualifiedAccessExpression, data)
+    }
+
+    open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult<FirStatement> {
+        return transformQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
+    open fun transformResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): CompositeTransformResult<FirStatement> {
+        return transformUnknownTypeExpression(resolvedQualifier, data)
+    }
+
     open fun transformTryExpression(tryExpression: FirTryExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(tryExpression, data)
+        return transformUnknownTypeExpression(tryExpression, data)
     }
 
     open fun transformWhenExpression(whenExpression: FirWhenExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(whenExpression, data)
+        return transformUnknownTypeExpression(whenExpression, data)
     }
 
     open fun transformWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformExpression(whenSubjectExpression, data)
+        return transformUnknownTypeExpression(whenSubjectExpression, data)
     }
 
     open fun transformWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
@@ -308,6 +324,22 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformWrappedArgumentExpression(spreadArgumentExpression, data)
     }
 
+    open fun transformClass(klass: FirClass, data: D): CompositeTransformResult<FirStatement> {
+        return transformStatement(klass, data)
+    }
+
+    open fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: D): CompositeTransformResult<FirStatement> {
+        return transformClass(anonymousObject, data)
+    }
+
+    open fun transformModifiableClass(modifiableClass: FirModifiableClass, data: D): CompositeTransformResult<FirStatement> {
+        return transformClass(modifiableClass, data)
+    }
+
+    open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
+        return transformStatement(errorStatement, data)
+    }
+
     open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult<FirStatement> {
         return transformStatement(loop, data)
     }
@@ -332,18 +364,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformAssignment(variableAssignment, data)
     }
 
-    open fun transformModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, data: D): CompositeTransformResult<FirStatement> {
+    open fun <C : FirReference> transformModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): CompositeTransformResult<FirStatement> {
         return transformQualifiedAccess(modifiableQualifiedAccess, data)
     }
 
-    open fun transformQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccess(qualifiedAccessExpression, data)
-    }
-
-    open fun transformCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): CompositeTransformResult<FirStatement> {
-        return transformQualifiedAccessExpression(callableReferenceAccess, data)
-    }
-
     open fun <E : FirElement> transformTargetElement(targetElement: E, data: D): CompositeTransformResult<E> {
         return transformElement(targetElement, data)
     }
@@ -408,6 +432,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(whenBranch, data)
     }
 
+    final override fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): CompositeTransformResult<FirElement> {
+        return transformAnnotatedStatement(annotatedStatement, data)
+    }
+
     final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult<FirElement> {
         return transformAnnotationCall(annotationCall, data)
     }
@@ -448,6 +476,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformCall(call, data)
     }
 
+    final override fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): CompositeTransformResult<FirElement> {
+        return transformCallWithArgumentList(callWithArgumentList, data)
+    }
+
     final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: D): CompositeTransformResult<FirElement> {
         return transformCallableDeclaration(callableDeclaration, data)
     }
@@ -600,6 +632,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformLoop(loop, data)
     }
 
+    final override fun visitLoopJump(loopJump: FirLoopJump, data: D): CompositeTransformResult<FirElement> {
+        return transformLoopJump(loopJump, data)
+    }
+
     final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): CompositeTransformResult<FirElement> {
         return transformMemberDeclaration(memberDeclaration, data)
     }
@@ -612,7 +648,7 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformModifiableFunction(modifiableFunction, data)
     }
 
-    final override fun visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, data: D): CompositeTransformResult<FirElement> {
+    final override fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): CompositeTransformResult<FirElement> {
         return transformModifiableQualifiedAccess(modifiableQualifiedAccess, data)
     }
 
@@ -632,6 +668,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformNamedReference(namedReference, data)
     }
 
+    final override fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): CompositeTransformResult<FirElement> {
+        return transformOperationBasedCall(operationBasedCall, data)
+    }
+
     final override fun visitOperatorCall(operatorCall: FirOperatorCall, data: D): CompositeTransformResult<FirElement> {
         return transformOperatorCall(operatorCall, data)
     }
@@ -764,6 +804,14 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformUncheckedNotNullCast(uncheckedNotNullCast, data)
     }
 
+    final override fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): CompositeTransformResult<FirElement> {
+        return transformUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList, data)
+    }
+
+    final override fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): CompositeTransformResult<FirElement> {
+        return transformUnknownTypeExpression(unknownTypeExpression, data)
+    }
+
     final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: D): CompositeTransformResult<FirElement> {
         return transformUserTypeRef(userTypeRef, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt

@@ -172,52 +172,60 @@ abstract class FirVisitor<out R, in D> {
         return visitElement(statement, data)
     }
 
-    open fun visitClass(klass: FirClass, data: D): R {
-        return visitStatement(klass, data)
-    }
-
-    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R {
-        return visitClass(anonymousObject, data)
-    }
-
-    open fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): R {
-        return visitClass(modifiableClass, data)
-    }
-
-    open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
-        return visitStatement(errorStatement, data)
+    open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: D): R {
+        return visitStatement(annotatedStatement, data)
     }
 
     open fun visitExpression(expression: FirExpression, data: D): R {
-        return visitStatement(expression, data)
-    }
-
-    open fun visitBlock(block: FirBlock, data: D): R {
-        return visitExpression(block, data)
+        return visitAnnotatedStatement(expression, data)
     }
 
     open fun visitCall(call: FirCall, data: D): R {
         return visitExpression(call, data)
     }
 
-    open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R {
-        return visitCall(annotationCall, data)
-    }
-
-    open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R {
-        return visitCall(arrayOfCall, data)
-    }
-
     open fun visitArraySetCall(arraySetCall: FirArraySetCall, data: D): R {
         return visitCall(arraySetCall, data)
     }
 
+    open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: D): R {
+        return visitCall(callWithArgumentList, data)
+    }
+
     open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R {
-        return visitCall(delegatedConstructorCall, data)
+        return visitCallWithArgumentList(delegatedConstructorCall, data)
+    }
+
+    open fun visitOperatorCall(operatorCall: FirOperatorCall, data: D): R {
+        return visitCallWithArgumentList(operatorCall, data)
+    }
+
+    open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: D): R {
+        return visitOperatorCall(operationBasedCall, data)
+    }
+
+    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R {
+        return visitOperationBasedCall(typeOperatorCall, data)
+    }
+
+    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R {
+        return visitCallWithArgumentList(stringConcatenationCall, data)
+    }
+
+    open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: D): R {
+        return visitCallWithArgumentList(unknownTypeCallWithArgumentList, data)
+    }
+
+    open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R {
+        return visitUnknownTypeCallWithArgumentList(annotationCall, data)
+    }
+
+    open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R {
+        return visitUnknownTypeCallWithArgumentList(arrayOfCall, data)
     }
 
     open fun visitFunctionCall(functionCall: FirFunctionCall, data: D): R {
-        return visitCall(functionCall, data)
+        return visitUnknownTypeCallWithArgumentList(functionCall, data)
     }
 
     open fun visitComponentCall(componentCall: FirComponentCall, data: D): R {
@@ -225,71 +233,79 @@ abstract class FirVisitor<out R, in D> {
     }
 
     open fun visitGetClassCall(getClassCall: FirGetClassCall, data: D): R {
-        return visitCall(getClassCall, data)
-    }
-
-    open fun visitOperatorCall(operatorCall: FirOperatorCall, data: D): R {
-        return visitCall(operatorCall, data)
-    }
-
-    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: D): R {
-        return visitOperatorCall(typeOperatorCall, data)
-    }
-
-    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: D): R {
-        return visitCall(stringConcatenationCall, data)
+        return visitUnknownTypeCallWithArgumentList(getClassCall, data)
     }
 
     open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast, data: D): R {
-        return visitCall(uncheckedNotNullCast, data)
-    }
-
-    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R {
-        return visitExpression(classReferenceExpression, data)
-    }
-
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R {
-        return visitExpression(constExpression, data)
-    }
-
-    open fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R {
-        return visitExpression(errorExpression, data)
+        return visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, data)
     }
 
     open fun <E : FirTargetElement> visitJump(jump: FirJump<E>, data: D): R {
         return visitExpression(jump, data)
     }
 
+    open fun visitLoopJump(loopJump: FirLoopJump, data: D): R {
+        return visitJump(loopJump, data)
+    }
+
     open fun visitBreakExpression(breakExpression: FirBreakExpression, data: D): R {
-        return visitJump(breakExpression, data)
+        return visitLoopJump(breakExpression, data)
     }
 
     open fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R {
-        return visitJump(continueExpression, data)
+        return visitLoopJump(continueExpression, data)
     }
 
     open fun visitReturnExpression(returnExpression: FirReturnExpression, data: D): R {
         return visitJump(returnExpression, data)
     }
 
-    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R {
-        return visitExpression(resolvedQualifier, data)
-    }
-
     open fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): R {
         return visitExpression(throwExpression, data)
     }
 
+    open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: D): R {
+        return visitExpression(unknownTypeExpression, data)
+    }
+
+    open fun visitBlock(block: FirBlock, data: D): R {
+        return visitUnknownTypeExpression(block, data)
+    }
+
+    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: D): R {
+        return visitUnknownTypeExpression(classReferenceExpression, data)
+    }
+
+    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R {
+        return visitUnknownTypeExpression(constExpression, data)
+    }
+
+    open fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R {
+        return visitUnknownTypeExpression(errorExpression, data)
+    }
+
+    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R {
+        return visitUnknownTypeExpression(qualifiedAccessExpression, data)
+    }
+
+    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R {
+        return visitQualifiedAccessExpression(callableReferenceAccess, data)
+    }
+
+    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: D): R {
+        return visitUnknownTypeExpression(resolvedQualifier, data)
+    }
+
     open fun visitTryExpression(tryExpression: FirTryExpression, data: D): R {
-        return visitExpression(tryExpression, data)
+        return visitUnknownTypeExpression(tryExpression, data)
     }
 
     open fun visitWhenExpression(whenExpression: FirWhenExpression, data: D): R {
-        return visitExpression(whenExpression, data)
+        return visitUnknownTypeExpression(whenExpression, data)
     }
 
     open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: D): R {
-        return visitExpression(whenSubjectExpression, data)
+        return visitUnknownTypeExpression(whenSubjectExpression, data)
     }
 
     open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: D): R {
@@ -308,6 +324,22 @@ abstract class FirVisitor<out R, in D> {
         return visitWrappedArgumentExpression(spreadArgumentExpression, data)
     }
 
+    open fun visitClass(klass: FirClass, data: D): R {
+        return visitStatement(klass, data)
+    }
+
+    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R {
+        return visitClass(anonymousObject, data)
+    }
+
+    open fun visitModifiableClass(modifiableClass: FirModifiableClass, data: D): R {
+        return visitClass(modifiableClass, data)
+    }
+
+    open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
+        return visitStatement(errorStatement, data)
+    }
+
     open fun visitLoop(loop: FirLoop, data: D): R {
         return visitStatement(loop, data)
     }
@@ -332,18 +364,10 @@ abstract class FirVisitor<out R, in D> {
         return visitAssignment(variableAssignment, data)
     }
 
-    open fun visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, data: D): R {
+    open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: D): R {
         return visitQualifiedAccess(modifiableQualifiedAccess, data)
     }
 
-    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R {
-        return visitQualifiedAccess(qualifiedAccessExpression, data)
-    }
-
-    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: D): R {
-        return visitQualifiedAccessExpression(callableReferenceAccess, data)
-    }
-
     open fun visitTargetElement(targetElement: FirTargetElement, data: D): R {
         return visitElement(targetElement, data)
     }

compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt

@@ -172,52 +172,60 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(statement, null)
     }
 
-    open fun visitClass(klass: FirClass) {
-        visitStatement(klass, null)
-    }
-
-    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
-        visitClass(anonymousObject, null)
-    }
-
-    open fun visitModifiableClass(modifiableClass: FirModifiableClass) {
-        visitClass(modifiableClass, null)
-    }
-
-    open fun visitErrorStatement(errorStatement: FirErrorStatement) {
-        visitStatement(errorStatement, null)
+    open fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement) {
+        visitStatement(annotatedStatement, null)
     }
 
     open fun visitExpression(expression: FirExpression) {
-        visitStatement(expression, null)
-    }
-
-    open fun visitBlock(block: FirBlock) {
-        visitExpression(block, null)
+        visitAnnotatedStatement(expression, null)
     }
 
     open fun visitCall(call: FirCall) {
         visitExpression(call, null)
     }
 
-    open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
-        visitCall(annotationCall, null)
-    }
-
-    open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
-        visitCall(arrayOfCall, null)
-    }
-
     open fun visitArraySetCall(arraySetCall: FirArraySetCall) {
         visitCall(arraySetCall, null)
     }
 
+    open fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList) {
+        visitCall(callWithArgumentList, null)
+    }
+
     open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
-        visitCall(delegatedConstructorCall, null)
+        visitCallWithArgumentList(delegatedConstructorCall, null)
+    }
+
+    open fun visitOperatorCall(operatorCall: FirOperatorCall) {
+        visitCallWithArgumentList(operatorCall, null)
+    }
+
+    open fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall) {
+        visitOperatorCall(operationBasedCall, null)
+    }
+
+    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
+        visitOperationBasedCall(typeOperatorCall, null)
+    }
+
+    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
+        visitCallWithArgumentList(stringConcatenationCall, null)
+    }
+
+    open fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList) {
+        visitCallWithArgumentList(unknownTypeCallWithArgumentList, null)
+    }
+
+    open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
+        visitUnknownTypeCallWithArgumentList(annotationCall, null)
+    }
+
+    open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
+        visitUnknownTypeCallWithArgumentList(arrayOfCall, null)
     }
 
     open fun visitFunctionCall(functionCall: FirFunctionCall) {
-        visitCall(functionCall, null)
+        visitUnknownTypeCallWithArgumentList(functionCall, null)
     }
 
     open fun visitComponentCall(componentCall: FirComponentCall) {
@@ -225,71 +233,79 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
     }
 
     open fun visitGetClassCall(getClassCall: FirGetClassCall) {
-        visitCall(getClassCall, null)
-    }
-
-    open fun visitOperatorCall(operatorCall: FirOperatorCall) {
-        visitCall(operatorCall, null)
-    }
-
-    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
-        visitOperatorCall(typeOperatorCall, null)
-    }
-
-    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
-        visitCall(stringConcatenationCall, null)
+        visitUnknownTypeCallWithArgumentList(getClassCall, null)
     }
 
     open fun visitUncheckedNotNullCast(uncheckedNotNullCast: FirUncheckedNotNullCast) {
-        visitCall(uncheckedNotNullCast, null)
-    }
-
-    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
-        visitExpression(classReferenceExpression, null)
-    }
-
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
-        visitExpression(constExpression, null)
-    }
-
-    open fun visitErrorExpression(errorExpression: FirErrorExpression) {
-        visitExpression(errorExpression, null)
+        visitUnknownTypeCallWithArgumentList(uncheckedNotNullCast, null)
     }
 
     open fun <E : FirTargetElement> visitJump(jump: FirJump<E>) {
         visitExpression(jump, null)
     }
 
+    open fun visitLoopJump(loopJump: FirLoopJump) {
+        visitJump(loopJump, null)
+    }
+
     open fun visitBreakExpression(breakExpression: FirBreakExpression) {
-        visitJump(breakExpression, null)
+        visitLoopJump(breakExpression, null)
     }
 
     open fun visitContinueExpression(continueExpression: FirContinueExpression) {
-        visitJump(continueExpression, null)
+        visitLoopJump(continueExpression, null)
     }
 
     open fun visitReturnExpression(returnExpression: FirReturnExpression) {
         visitJump(returnExpression, null)
     }
 
-    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
-        visitExpression(resolvedQualifier, null)
-    }
-
     open fun visitThrowExpression(throwExpression: FirThrowExpression) {
         visitExpression(throwExpression, null)
     }
 
+    open fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression) {
+        visitExpression(unknownTypeExpression, null)
+    }
+
+    open fun visitBlock(block: FirBlock) {
+        visitUnknownTypeExpression(block, null)
+    }
+
+    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
+        visitUnknownTypeExpression(classReferenceExpression, null)
+    }
+
+    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
+        visitUnknownTypeExpression(constExpression, null)
+    }
+
+    open fun visitErrorExpression(errorExpression: FirErrorExpression) {
+        visitUnknownTypeExpression(errorExpression, null)
+    }
+
+    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
+        visitUnknownTypeExpression(qualifiedAccessExpression, null)
+    }
+
+    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
+        visitQualifiedAccessExpression(callableReferenceAccess, null)
+    }
+
+    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
+        visitUnknownTypeExpression(resolvedQualifier, null)
+    }
+
     open fun visitTryExpression(tryExpression: FirTryExpression) {
-        visitExpression(tryExpression, null)
+        visitUnknownTypeExpression(tryExpression, null)
     }
 
     open fun visitWhenExpression(whenExpression: FirWhenExpression) {
-        visitExpression(whenExpression, null)
+        visitUnknownTypeExpression(whenExpression, null)
     }
 
     open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) {
-        visitExpression(whenSubjectExpression, null)
+        visitUnknownTypeExpression(whenSubjectExpression, null)
     }
 
     open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) {
@@ -308,6 +324,22 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitWrappedArgumentExpression(spreadArgumentExpression, null)
     }
 
+    open fun visitClass(klass: FirClass) {
+        visitStatement(klass, null)
+    }
+
+    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+        visitClass(anonymousObject, null)
+    }
+
+    open fun visitModifiableClass(modifiableClass: FirModifiableClass) {
+        visitClass(modifiableClass, null)
+    }
+
+    open fun visitErrorStatement(errorStatement: FirErrorStatement) {
+        visitStatement(errorStatement, null)
+    }
+
     open fun visitLoop(loop: FirLoop) {
         visitStatement(loop, null)
     }
@@ -332,18 +364,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitAssignment(variableAssignment, null)
     }
 
-    open fun visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess) {
+    open fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>) {
         visitQualifiedAccess(modifiableQualifiedAccess, null)
     }
 
-    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
-        visitQualifiedAccess(qualifiedAccessExpression, null)
-    }
-
-    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
-        visitQualifiedAccessExpression(callableReferenceAccess, null)
-    }
-
     open fun visitTargetElement(targetElement: FirTargetElement) {
         visitElement(targetElement, null)
     }
@@ -408,6 +432,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(whenBranch, null)
     }
 
+    final override fun visitAnnotatedStatement(annotatedStatement: FirAnnotatedStatement, data: Nothing?) {
+        visitAnnotatedStatement(annotatedStatement)
+    }
+
     final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) {
         visitAnnotationCall(annotationCall)
     }
@@ -448,6 +476,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitCall(call)
     }
 
+    final override fun visitCallWithArgumentList(callWithArgumentList: FirCallWithArgumentList, data: Nothing?) {
+        visitCallWithArgumentList(callWithArgumentList)
+    }
+
     final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) {
         visitCallableDeclaration(callableDeclaration)
     }
@@ -600,6 +632,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitLoop(loop)
     }
 
+    final override fun visitLoopJump(loopJump: FirLoopJump, data: Nothing?) {
+        visitLoopJump(loopJump)
+    }
+
     final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) {
         visitMemberDeclaration(memberDeclaration)
     }
@@ -612,7 +648,7 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitModifiableFunction(modifiableFunction)
     }
 
-    final override fun visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess, data: Nothing?) {
+    final override fun <C : FirReference> visitModifiableQualifiedAccess(modifiableQualifiedAccess: FirModifiableQualifiedAccess<C>, data: Nothing?) {
         visitModifiableQualifiedAccess(modifiableQualifiedAccess)
     }
 
@@ -632,6 +668,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitNamedReference(namedReference)
     }
 
+    final override fun visitOperationBasedCall(operationBasedCall: FirOperationBasedCall, data: Nothing?) {
+        visitOperationBasedCall(operationBasedCall)
+    }
+
     final override fun visitOperatorCall(operatorCall: FirOperatorCall, data: Nothing?) {
         visitOperatorCall(operatorCall)
     }
@@ -764,6 +804,14 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitUncheckedNotNullCast(uncheckedNotNullCast)
     }
 
+    final override fun visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList: FirUnknownTypeCallWithArgumentList, data: Nothing?) {
+        visitUnknownTypeCallWithArgumentList(unknownTypeCallWithArgumentList)
+    }
+
+    final override fun visitUnknownTypeExpression(unknownTypeExpression: FirUnknownTypeExpression, data: Nothing?) {
+        visitUnknownTypeExpression(unknownTypeExpression)
+    }
+
     final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?) {
         visitUserTypeRef(userTypeRef)
     }