IR: push down implementations of startOffset/endOffset/type/...

Do not store these as properties in IrElementBase, IrExpressionBase and
similar classes. This helps to reduce boilerplate in implementations
(just "override val" in the constructor, instead of taking a parameter
and passing it to the superclass), and also slightly optimizes memory in
cases where the value is trivial (UNDEFINED_OFFSET, 0, etc) and thus
does not need to be stored.

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/inline/FunctionInlining.kt

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.backend.common.ir.Symbols
 import org.jetbrains.kotlin.backend.common.ir.createTemporaryVariableWithWrappedDescriptor
 import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
 import org.jetbrains.kotlin.config.languageVersionSettings
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.irReturn
 import org.jetbrains.kotlin.ir.declarations.*
@@ -509,13 +509,14 @@ class FunctionInlining(
     }
 
     private class IrGetValueWithoutLocation(
-        symbol: IrValueSymbol,
+        override val symbol: IrValueSymbol,
         override val origin: IrStatementOrigin? = null
-    ) : IrTerminalDeclarationReferenceBase<IrValueSymbol>(
+    ) : IrTerminalDeclarationReferenceBase<IrValueSymbol>(), IrGetValue {
-        UNDEFINED_OFFSET, UNDEFINED_OFFSET,
+        override val startOffset: Int get() = UNDEFINED_OFFSET
-        symbol.owner.type,
+        override val endOffset: Int get() = UNDEFINED_OFFSET
-        symbol
+
-    ), IrGetValue {
+        override val type: IrType get() = symbol.owner.type
+
         override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D) =
             visitor.visitGetValue(this, data)
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/coroutines/StateMachineBuilder.kt

@@ -24,7 +24,10 @@ import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
 import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.IrDynamicType
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.isNothing
+import org.jetbrains.kotlin.ir.types.isUnit
 import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
 import org.jetbrains.kotlin.ir.util.getInlinedClass
 import org.jetbrains.kotlin.ir.visitors.*
@@ -39,7 +42,12 @@ data class LoopBounds(val headState: SuspendState, val exitState: SuspendState)
 
 data class TryState(val tryState: SuspendState, val catchState: SuspendState)
 
-class IrDispatchPoint(val target: SuspendState) : IrExpressionBase(UNDEFINED_OFFSET, UNDEFINED_OFFSET, target.entryBlock.type) {
+class IrDispatchPoint(val target: SuspendState) : IrExpressionBase() {
+    override val startOffset: Int get() = UNDEFINED_OFFSET
+    override val endOffset: Int get() = UNDEFINED_OFFSET
+
+    override val type: IrType get() = target.entryBlock.type
+
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D) = visitor.visitExpression(this, data)
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {}

compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt

@@ -22,7 +22,10 @@ import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 
-class IrBlockBodyImpl(startOffset: Int, endOffset: Int) : IrElementBase(startOffset, endOffset), IrBlockBody {
+class IrBlockBodyImpl(
+    override val startOffset: Int,
+    override val endOffset: Int
+) : IrElementBase(), IrBlockBody {
     constructor(startOffset: Int, endOffset: Int, statements: List<IrStatement>) : this(startOffset, endOffset) {
         this.statements.addAll(statements)
     }

compiler/ir/ir.tree.impl/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt

@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 
 class IrExpressionBodyImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     initializer: (IrExpressionBody.() -> Unit)? = null
-) : IrElementBase(startOffset, endOffset), IrExpressionBody {
+) : IrElementBase(), IrExpressionBody {
     init {
         initializer?.invoke(this)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrElementBase.kt

@@ -16,4 +16,4 @@
 
 package org.jetbrains.kotlin.ir
 
-abstract class IrElementBase(override val startOffset: Int, override val endOffset: Int) : IrElement
+abstract class IrElementBase : IrElement

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrExternalPackageFragmentImpl.kt

@@ -35,9 +35,15 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ
 class IrExternalPackageFragmentImpl(
     override val symbol: IrExternalPackageFragmentSymbol,
     override val fqName: FqName
-) : IrElementBase(UNDEFINED_OFFSET, UNDEFINED_OFFSET),
+) : IrElementBase(),
     IrExternalPackageFragment {
 
+    override val startOffset: Int
+        get() = UNDEFINED_OFFSET
+
+    override val endOffset: Int
+        get() = UNDEFINED_OFFSET
+
     init {
         symbol.bind(this)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFileImpl.kt

@@ -34,10 +34,7 @@ class IrFileImpl(
     override val fileEntry: SourceManager.FileEntry,
     override val symbol: IrFileSymbol,
     override val fqName: FqName
-) :
+) : IrElementBase(), IrFile {
-    IrElementBase(0, fileEntry.maxOffset),
-    IrFile {
-
     constructor(
         fileEntry: SourceManager.FileEntry,
         packageFragmentDescriptor: PackageFragmentDescriptor
@@ -47,6 +44,12 @@ class IrFileImpl(
         symbol.bind(this)
     }
 
+    override val startOffset: Int
+        get() = 0
+
+    override val endOffset: Int
+        get() = fileEntry.maxOffset
+
     @ObsoleteDescriptorBasedAPI
     override val packageFragmentDescriptor: PackageFragmentDescriptor get() = symbol.descriptor
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt

@@ -29,22 +29,18 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrBlockImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrContainerExpressionBase(), IrBlock {
-    IrContainerExpressionBase(startOffset, endOffset, type, origin),
-    IrBlock {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
         type: IrType,
         origin: IrStatementOrigin?,
         statements: List<IrStatement>
-    ) :
+    ) : this(startOffset, endOffset, type, origin) {
-        this(startOffset, endOffset, type, origin) {
         this.statements.addAll(statements)
     }
 
@@ -65,16 +61,13 @@ fun IrBlockImpl.inlineStatement(statement: IrStatement) {
 }
 
 class IrReturnableBlockImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrReturnableBlockSymbol,
-    origin: IrStatementOrigin? = null,
+    override val origin: IrStatementOrigin? = null,
     override val inlineFunctionSymbol: IrFunctionSymbol? = null
-) :
+) : IrContainerExpressionBase(), IrReturnableBlock {
-    IrContainerExpressionBase(startOffset, endOffset, type, origin),
-    IrReturnableBlock {
-
     @ObsoleteDescriptorBasedAPI
     override val descriptor: FunctionDescriptor
         get() = symbol.descriptor

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBreakContinueBase.kt

@@ -17,16 +17,7 @@
 package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrBreakContinue
-import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.types.IrType
-
-abstract class IrBreakContinueBase(
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
-    override var loop: IrLoop
-) : IrTerminalExpressionBase(startOffset, endOffset, type),
-    IrBreakContinue {
 
+abstract class IrBreakContinueBase : IrTerminalExpressionBase(), IrBreakContinue {
     override var label: String? = null
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBreakImpl.kt

@@ -22,13 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrBreakImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    loop: IrLoop
+    override var loop: IrLoop,
-) : IrBreakContinueBase(startOffset, endOffset, type, loop),
+) : IrBreakContinueBase(), IrBreak {
-    IrBreak {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitBreak(this, data)
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt

@@ -28,23 +28,15 @@ import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrFunctionSymbol,
     typeArgumentsCount: Int,
     valueArgumentsCount: Int,
-    origin: IrStatementOrigin? = null,
+    override val origin: IrStatementOrigin? = null,
     override val superQualifierSymbol: IrClassSymbol? = null
-) :
+) : IrCallWithIndexedArgumentsBase(typeArgumentsCount, valueArgumentsCount), IrCall {
-    IrCallWithIndexedArgumentsBase(
-        startOffset, endOffset, type,
-        typeArgumentsCount,
-        valueArgumentsCount,
-        origin
-    ),
-    IrCall {
-
     init {
         if (symbol is IrConstructorSymbol) {
             throw AssertionError("Should be IrConstructorCall: ${this.render()}")

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallWithIndexedArgumentsBase.kt

@@ -17,29 +17,14 @@
 package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
-import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 abstract class IrCallWithIndexedArgumentsBase(
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
     typeArgumentsCount: Int,
-    valueArgumentsCount: Int,
+    final override val valueArgumentsCount: Int,
-    origin: IrStatementOrigin? = null
+) : IrMemberAccessExpressionBase<IrFunctionSymbol>(typeArgumentsCount) {
-) :
-    IrMemberAccessExpressionBase<IrFunctionSymbol>(
-        startOffset,
-        endOffset,
-        type,
-        typeArgumentsCount,
-        valueArgumentsCount,
-        origin
-    ) {
-
     private val argumentsByParameterIndex: Array<IrExpression?> = arrayOfNulls(valueArgumentsCount)
 
     override fun getValueArgument(index: Int): IrExpression? {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrClassReferenceImpl.kt

@@ -22,13 +22,12 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrClassReferenceImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    symbol: IrClassifierSymbol,
+    override val symbol: IrClassifierSymbol,
     override val classType: IrType
-) : IrTerminalDeclarationReferenceBase<IrClassifierSymbol>(startOffset, endOffset, type, symbol), IrClassReference {
+) : IrTerminalDeclarationReferenceBase<IrClassifierSymbol>(), IrClassReference {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitClassReference(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCompositeImpl.kt

@@ -22,16 +22,12 @@ import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-
 class IrCompositeImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrContainerExpressionBase(), IrComposite {
-    IrContainerExpressionBase(startOffset, endOffset, type, origin),
-    IrComposite {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
@@ -44,5 +40,4 @@ class IrCompositeImpl(
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitComposite(this, data)
-
+}
-}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstImpl.kt

@@ -18,20 +18,16 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
-import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrConstImpl<T>(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val kind: IrConstKind<T>,
     override val value: T
-) :
+) : IrTerminalExpressionBase(), IrConst<T> {
-    IrTerminalExpressionBase(startOffset, endOffset, type),
-    IrConst<T> {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitConst(this, data)
 
@@ -87,4 +83,4 @@ class IrConstImpl<T>(
             else -> constNull(startOffset, endOffset, type)
         }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrConstructorCallImpl.kt

@@ -15,18 +15,15 @@ import org.jetbrains.kotlin.ir.util.parentAsClass
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrConstructorCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrConstructorSymbol,
     typeArgumentsCount: Int,
     override val constructorTypeArgumentsCount: Int,
     valueArgumentsCount: Int,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrCallWithIndexedArgumentsBase(typeArgumentsCount, valueArgumentsCount), IrConstructorCall {
-    IrCallWithIndexedArgumentsBase(startOffset, endOffset, type, typeArgumentsCount, valueArgumentsCount, origin),
-    IrConstructorCall {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitConstructorCall(this, data)
 
@@ -92,7 +89,9 @@ class IrConstructorCallImpl(
         }
 
         fun fromSymbolOwner(type: IrType, constructorSymbol: IrConstructorSymbol, origin: IrStatementOrigin? = null) =
-            fromSymbolOwner(UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, constructorSymbol, constructorSymbol.owner.parentAsClass.typeParameters.size, origin)
+            fromSymbolOwner(
+                UNDEFINED_OFFSET, UNDEFINED_OFFSET, type, constructorSymbol, constructorSymbol.owner.parentAsClass.typeParameters.size,
+                origin
+            )
     }
 }
-

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrContainerExpressionBase.kt

@@ -18,22 +18,12 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.expressions.IrContainerExpression
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.transform
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import java.util.*
 
-abstract class IrContainerExpressionBase(
+abstract class IrContainerExpressionBase : IrExpressionBase(), IrContainerExpression {
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
-    override val origin: IrStatementOrigin? = null
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrContainerExpression {
-
     override val statements: MutableList<IrStatement> = ArrayList(2)
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
@@ -43,4 +33,4 @@ abstract class IrContainerExpressionBase(
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         statements.transform { it.transform(transformer, data) }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrContinueImpl.kt

@@ -22,14 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrContinueImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    loop: IrLoop
+    override var loop: IrLoop,
-) :
+) : IrBreakContinueBase(), IrContinue {
-    IrBreakContinueBase(startOffset, endOffset, type, loop),
-    IrContinue {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitContinue(this, data)
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDeclarationReferenceBase.kt

@@ -18,13 +18,7 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.types.IrType
 
-abstract class IrDeclarationReferenceBase<out S : IrSymbol>(
+abstract class IrDeclarationReferenceBase<out S : IrSymbol> : IrExpressionBase(), IrDeclarationReference {
-    startOffset: Int,
+    abstract override val symbol: S
-    endOffset: Int,
+}
-    type: IrType,
-    override val symbol: S
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrDeclarationReference

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDelegatingConstructorCallImpl.kt

@@ -18,27 +18,22 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.expressions.typeParametersCount
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrDelegatingConstructorCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrConstructorSymbol,
     typeArgumentsCount: Int,
     valueArgumentsCount: Int
-) :
+) : IrCallWithIndexedArgumentsBase(typeArgumentsCount, valueArgumentsCount), IrDelegatingConstructorCall {
-    IrCallWithIndexedArgumentsBase(
+    override val origin: IrStatementOrigin?
-        startOffset,
+        get() = null
-        endOffset,
-        type,
-        typeArgumentsCount = typeArgumentsCount,
-        valueArgumentsCount = valueArgumentsCount
-    ),
-    IrDelegatingConstructorCall {
 
     @ObsoleteDescriptorBasedAPI
     constructor(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDoWhileLoopImpl.kt

@@ -23,14 +23,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrDoWhileLoopImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin?
+    override val origin: IrStatementOrigin?,
-) :
+) : IrLoopBase(), IrDoWhileLoop {
-    IrLoopBase(startOffset, endOffset, type, origin),
-    IrDoWhileLoop {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitDoWhileLoop(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDynamicMemberExpressionImpl.kt

@@ -12,15 +12,12 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrDynamicMemberExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val memberName: String,
     override var receiver: IrExpression
-) :
+) : IrExpressionBase(), IrDynamicMemberExpression {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrDynamicMemberExpression {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitDynamicMemberExpression(this, data)
 
@@ -31,4 +28,4 @@ class IrDynamicMemberExpressionImpl(
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         receiver = receiver.transform(transformer, data)
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrDynamicOperatorExpressionImpl.kt

@@ -14,14 +14,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.utils.SmartList
 
 class IrDynamicOperatorExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val operator: IrDynamicOperator
-) :
+) : IrExpressionBase(), IrDynamicOperatorExpression {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrDynamicOperatorExpression {
-
     override lateinit var receiver: IrExpression
 
     override val arguments: MutableList<IrExpression> = SmartList()
@@ -42,4 +39,4 @@ class IrDynamicOperatorExpressionImpl(
             arguments[i] = arguments[i].transform(transformer, data)
         }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrEnumConstructorCallImpl.kt

@@ -18,26 +18,21 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrEnumConstructorCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrConstructorSymbol,
     typeArgumentsCount: Int,
     valueArgumentsCount: Int
-) :
+) : IrCallWithIndexedArgumentsBase(typeArgumentsCount, valueArgumentsCount), IrEnumConstructorCall {
-    IrCallWithIndexedArgumentsBase(
+    override val origin: IrStatementOrigin?
-        startOffset,
+        get() = null
-        endOffset,
-        type,
-        typeArgumentsCount = typeArgumentsCount,
-        valueArgumentsCount = valueArgumentsCount
-    ),
-    IrEnumConstructorCall {
 
     @ObsoleteDescriptorBasedAPI
     constructor(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrErrorCallExpressionImpl.kt

@@ -24,14 +24,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.utils.SmartList
 
 class IrErrorCallExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val description: String
-) :
+) : IrExpressionBase(), IrErrorCallExpression {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrErrorCallExpression {
-
     override var explicitReceiver: IrExpression? = null
     override val arguments: MutableList<IrExpression> = SmartList()
 
@@ -54,4 +51,4 @@ class IrErrorCallExpressionImpl(
             arguments[i] = irExpression.transform(transformer, data)
         }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrErrorExpressionImpl.kt

@@ -22,18 +22,14 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrErrorExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val description: String
-) :
+) : IrTerminalExpressionBase(), IrExpressionWithCopy, IrErrorExpression {
-    IrTerminalExpressionBase(startOffset, endOffset, type),
-    IrExpressionWithCopy,
-    IrErrorExpression {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitErrorExpression(this, data)
 
     override fun copy(): IrErrorExpressionImpl =
         IrErrorExpressionImpl(startOffset, endOffset, type, description)
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBase.kt

@@ -19,13 +19,8 @@ package org.jetbrains.kotlin.ir.expressions.impl
 import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.declarations.IrAttributeContainer
 import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.types.IrType
 
-abstract class IrExpressionBase(
+abstract class IrExpressionBase : IrElementBase(), IrExpression {
-    startOffset: Int,
-    endOffset: Int,
-    override val type: IrType
-) : IrElementBase(startOffset, endOffset), IrExpression {
     @Suppress("LeakingThis")
     override var attributeOwnerId: IrAttributeContainer = this
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFieldExpressionBase.kt

@@ -18,20 +18,7 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
-import org.jetbrains.kotlin.ir.types.IrType
-
-abstract class IrFieldExpressionBase(
-    startOffset: Int, endOffset: Int,
-    override val symbol: IrFieldSymbol,
-    type: IrType,
-    override val origin: IrStatementOrigin? = null,
-    override val superQualifierSymbol: IrClassSymbol?
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrFieldAccessExpression {
 
+abstract class IrFieldExpressionBase : IrExpressionBase(), IrFieldAccessExpression {
     final override var receiver: IrExpression? = null
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionExpressionImpl.kt

@@ -13,15 +13,12 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrFunctionExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override var function: IrSimpleFunction,
     override val origin: IrStatementOrigin
-) :
+) : IrExpressionBase(), IrFunctionExpression {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrFunctionExpression {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitFunctionExpression(this, data)
     }
@@ -33,4 +30,4 @@ class IrFunctionExpressionImpl(
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         function = function.transform(transformer, data) as IrSimpleFunction
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrFunctionReferenceImpl.kt

@@ -25,25 +25,15 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 
 class IrFunctionReferenceImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrFunctionSymbol,
     typeArgumentsCount: Int,
     valueArgumentsCount: Int,
     override val reflectionTarget: IrFunctionSymbol? = symbol,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrCallWithIndexedArgumentsBase(typeArgumentsCount, valueArgumentsCount), IrFunctionReference {
-    IrCallWithIndexedArgumentsBase(
-        startOffset,
-        endOffset,
-        type,
-        typeArgumentsCount,
-        valueArgumentsCount,
-        origin
-    ),
-    IrFunctionReference {
-
     @ObsoleteDescriptorBasedAPI
     constructor(
         startOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetClassImpl.kt

@@ -23,14 +23,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrGetClassImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override var argument: IrExpression,
-) :
+) : IrExpressionBase(), IrGetClass {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrGetClass {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitGetClass(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetEnumValueImpl.kt

@@ -22,12 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrGetEnumValueImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    symbol: IrEnumEntrySymbol
+    override val symbol: IrEnumEntrySymbol,
-) : IrTerminalDeclarationReferenceBase<IrEnumEntrySymbol>(startOffset, endOffset, type, symbol), IrGetEnumValue {
+) : IrTerminalDeclarationReferenceBase<IrEnumEntrySymbol>(), IrGetEnumValue {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitGetEnumValue(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetFieldImpl.kt

@@ -26,16 +26,13 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrGetFieldImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    symbol: IrFieldSymbol,
+    override val symbol: IrFieldSymbol,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin? = null,
+    override val origin: IrStatementOrigin? = null,
-    superQualifierSymbol: IrClassSymbol? = null
+    override val superQualifierSymbol: IrClassSymbol? = null,
-) :
+) : IrFieldExpressionBase(), IrGetField {
-    IrFieldExpressionBase(startOffset, endOffset, symbol, type, origin, superQualifierSymbol),
-    IrGetField {
-
     constructor(
         startOffset: Int, endOffset: Int,
         symbol: IrFieldSymbol,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetObjectValueImpl.kt

@@ -22,12 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrGetObjectValueImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    symbol: IrClassSymbol
+    override val symbol: IrClassSymbol
-) : IrTerminalDeclarationReferenceBase<IrClassSymbol>(startOffset, endOffset, type, symbol), IrGetObjectValue {
+) : IrTerminalDeclarationReferenceBase<IrClassSymbol>(), IrGetObjectValue {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitGetObjectValue(this, data)
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrGetValueImpl.kt

@@ -12,20 +12,12 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrGetValueImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    symbol: IrValueSymbol,
+    override val symbol: IrValueSymbol,
     override val origin: IrStatementOrigin? = null
-) :
+) : IrTerminalDeclarationReferenceBase<IrValueSymbol>(), IrGetValue {
-    IrTerminalDeclarationReferenceBase<IrValueSymbol>(
-        startOffset,
-        endOffset,
-        type,
-        symbol
-    ),
-    IrGetValue {
-
     constructor(
         startOffset: Int,
         endOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrIfThenElseImpl.kt

@@ -22,12 +22,10 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.utils.SmartList
 
 class IrIfThenElseImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val origin: IrStatementOrigin? = null
-) :
+) : IrWhenBase() {
-    IrWhenBase(startOffset, endOffset, type) {
-
     override val branches: MutableList<IrBranch> = SmartList()
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrInstanceInitializerCallImpl.kt

@@ -22,14 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrInstanceInitializerCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     override val classSymbol: IrClassSymbol,
-    type: IrType
+    override val type: IrType,
-) :
+) : IrTerminalExpressionBase(), IrInstanceInitializerCall {
-    IrTerminalExpressionBase(startOffset, endOffset, type),
-    IrInstanceInitializerCall {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitInstanceInitializerCall(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLocalDelegatedPropertyReferenceImpl.kt

@@ -27,17 +27,17 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 
 class IrLocalDelegatedPropertyReferenceImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrLocalDelegatedPropertySymbol,
     override val delegate: IrVariableSymbol,
     override val getter: IrSimpleFunctionSymbol,
     override val setter: IrSimpleFunctionSymbol?,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrMemberAccessExpressionBase<IrLocalDelegatedPropertySymbol>(0), IrLocalDelegatedPropertyReference {
-    IrMemberAccessExpressionBase<IrLocalDelegatedPropertySymbol>(startOffset, endOffset, type, 0, 0, origin),
+    override val valueArgumentsCount: Int
-    IrLocalDelegatedPropertyReference {
+        get() = 0
 
     override val referencedName: Name
         get() = symbol.owner.name

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrLoopBase.kt

@@ -18,21 +18,11 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.types.IrType
-
-abstract class IrLoopBase(
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
-    override val origin: IrStatementOrigin?
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrLoop {
 
+abstract class IrLoopBase : IrExpressionBase(), IrLoop {
     override var label: String? = null
 
     override lateinit var condition: IrExpression
 
     override var body: IrExpression? = null
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrMemberAccessExpressionBase.kt

@@ -18,23 +18,14 @@ package org.jetbrains.kotlin.ir.expressions.impl
 
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 abstract class IrMemberAccessExpressionBase<S : IrSymbol>(
-    startOffset: Int,
+    final override val typeArgumentsCount: Int
-    endOffset: Int,
+) : IrExpressionBase(), IrMemberAccessExpression<S> {
-    type: IrType,
-    final override val typeArgumentsCount: Int,
-    final override val valueArgumentsCount: Int,
-    final override val origin: IrStatementOrigin? = null
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrMemberAccessExpression<S> {
-
     override var dispatchReceiver: IrExpression? = null
     override var extensionReceiver: IrExpression? = null
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrPropertyReferenceImpl.kt

@@ -27,18 +27,18 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 
 class IrPropertyReferenceImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrPropertySymbol,
     typeArgumentsCount: Int,
     override val field: IrFieldSymbol?,
     override val getter: IrSimpleFunctionSymbol?,
     override val setter: IrSimpleFunctionSymbol?,
-    origin: IrStatementOrigin? = null
+    override val origin: IrStatementOrigin? = null,
-) :
+) : IrMemberAccessExpressionBase<IrPropertySymbol>(typeArgumentsCount), IrPropertyReference {
-    IrMemberAccessExpressionBase<IrPropertySymbol>(startOffset, endOffset, type, typeArgumentsCount, 0, origin),
+    override val valueArgumentsCount: Int
-    IrPropertyReference {
+        get() = 0
 
     override val referencedName: Name
         get() = symbol.owner.name

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrRawFunctionReferenceImpl.kt

@@ -22,12 +22,11 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrRawFunctionReferenceImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    symbol: IrFunctionSymbol
+    override val symbol: IrFunctionSymbol,
-) : IrTerminalDeclarationReferenceBase<IrFunctionSymbol>(startOffset, endOffset, type, symbol), IrRawFunctionReference {
+) : IrTerminalDeclarationReferenceBase<IrFunctionSymbol>(), IrRawFunctionReference {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitRawFunctionReference(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrReturnImpl.kt

@@ -24,15 +24,12 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrReturnImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val returnTargetSymbol: IrReturnTargetSymbol,
     override var value: IrExpression
-) :
+) : IrExpressionBase(), IrReturn {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrReturn {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitReturn(this, data)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetFieldImpl.kt

@@ -26,22 +26,13 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrSetFieldImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    symbol: IrFieldSymbol,
+    override val symbol: IrFieldSymbol,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin? = null,
+    override val origin: IrStatementOrigin? = null,
-    superQualifierSymbol: IrClassSymbol? = null
+    override val superQualifierSymbol: IrClassSymbol? = null,
-) :
+) : IrFieldExpressionBase(), IrSetField {
-    IrFieldExpressionBase(
-        startOffset, endOffset,
-        symbol,
-        type,
-        origin,
-        superQualifierSymbol
-    ),
-    IrSetField {
-
     constructor(
         startOffset: Int, endOffset: Int,
         symbol: IrFieldSymbol,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSetVariableImpl.kt

@@ -25,16 +25,13 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrSetVariableImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val symbol: IrVariableSymbol,
     override var value: IrExpression,
     override val origin: IrStatementOrigin?
-) :
+) : IrExpressionBase(), IrSetVariable {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrSetVariable {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitSetVariable(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSpreadElementImpl.kt

@@ -23,13 +23,10 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrSpreadElementImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     override var expression: IrExpression,
-) :
+) : IrElementBase(), IrSpreadElement {
-    IrElementBase(startOffset, endOffset),
-    IrSpreadElement {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitSpreadElement(this, data)
     }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrStringConcatenationImpl.kt

@@ -24,13 +24,10 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import java.util.*
 
 class IrStringConcatenationImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType
+    override val type: IrType
-) :
+) : IrExpressionBase(), IrStringConcatenation {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrStringConcatenation {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
@@ -58,4 +55,4 @@ class IrStringConcatenationImpl(
             arguments[i] = irExpression.transform(transformer, data)
         }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSuspendImpl.kt

@@ -14,14 +14,13 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrSuspensionPointImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override var suspensionPointIdParameter: IrVariable,
     override var result: IrExpression,
     override var resumeResult: IrExpression
-) : IrExpressionBase(startOffset, endOffset, type), IrSuspensionPoint {
+) : IrExpressionBase(), IrSuspensionPoint {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitSuspensionPoint(this, data)
 
@@ -39,12 +38,12 @@ class IrSuspensionPointImpl(
 }
 
 class IrSuspendableExpressionImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override var suspensionPointId: IrExpression,
     override var result: IrExpression
-) : IrExpressionBase(startOffset, endOffset, type), IrSuspendableExpression {
+) : IrExpressionBase(), IrSuspendableExpression {
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitSuspendableExpression(this, data)
@@ -58,4 +57,4 @@ class IrSuspendableExpressionImpl(
         suspensionPointId = suspensionPointId.transform(transformer, data)
         result = result.transform(transformer, data)
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrSyntheticBodyImpl.kt

@@ -23,12 +23,10 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrSyntheticBodyImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     override val kind: IrSyntheticBodyKind
-) :
+) : IrElementBase(), IrSyntheticBody {
-    IrElementBase(startOffset, endOffset),
-    IrSyntheticBody {
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitSyntheticBody(this, data)
     }
@@ -43,4 +41,4 @@ class IrSyntheticBodyImpl(
 
     override fun toString(): String =
         "IrSyntheticBodyImpl($kind)"
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalDeclarationReferenceBase.kt

@@ -16,21 +16,11 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-abstract class IrTerminalDeclarationReferenceBase<out S : IrSymbol>(
+abstract class IrTerminalDeclarationReferenceBase<out S : IrSymbol> : IrDeclarationReferenceBase<S>() {
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
-    symbol: S
-) :
-    IrDeclarationReferenceBase<S>(startOffset, endOffset, type, symbol),
-    IrDeclarationReference {
-
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         // No children
     }
@@ -38,4 +28,4 @@ abstract class IrTerminalDeclarationReferenceBase<out S : IrSymbol>(
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         // No children
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTerminalExpressionBase.kt

@@ -16,16 +16,10 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-abstract class IrTerminalExpressionBase(
+abstract class IrTerminalExpressionBase : IrExpressionBase() {
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType
-) : IrExpressionBase(startOffset, endOffset, type) {
-
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         // No children
     }
@@ -33,4 +27,4 @@ abstract class IrTerminalExpressionBase(
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         // No children
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrThrowImpl.kt

@@ -23,14 +23,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrThrowImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override var value: IrExpression,
-) :
+) : IrExpressionBase(), IrThrow {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrThrow {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitThrow(this, data)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTryImpl.kt

@@ -27,13 +27,10 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.utils.SmartList
 
 class IrTryImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType
+    override val type: IrType,
-) :
+) : IrExpressionBase(), IrTry {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrTry {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
@@ -73,13 +70,10 @@ class IrTryImpl(
 }
 
 class IrCatchImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     override var catchParameter: IrVariable,
-) :
+) : IrElementBase(), IrCatch {
-    IrElementBase(startOffset, endOffset),
-    IrCatch {
-
     constructor(
         startOffset: Int,
         endOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrTypeOperatorCallImpl.kt

@@ -26,16 +26,13 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrTypeOperatorCallImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val operator: IrTypeOperator,
     override val typeOperand: IrType,
     override var argument: IrExpression,
-) :
+) : IrExpressionBase(), IrTypeOperatorCall {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrTypeOperatorCall {
-
     override val typeOperandClassifier: IrClassifierSymbol
         get() = typeOperand.classifierOrFail
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrVarargImpl.kt

@@ -24,14 +24,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.utils.SmartList
 
 class IrVarargImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val varargElementType: IrType
-) :
+) : IrExpressionBase(), IrVararg {
-    IrExpressionBase(startOffset, endOffset, type),
-    IrVararg {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
@@ -65,4 +62,4 @@ class IrVarargImpl(
             elements[i] = irVarargElement.transform(transformer, data) as IrVarargElement
         }
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrWhenImpl.kt

@@ -23,15 +23,7 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import java.util.*
 
-abstract class IrWhenBase(
+abstract class IrWhenBase : IrExpressionBase(), IrWhen {
-    startOffset: Int,
-    endOffset: Int,
-    type: IrType,
-    override val origin: IrStatementOrigin? = null
-) :
-    IrExpressionBase(startOffset, endOffset, type),
-    IrWhen {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitWhen(this, data)
 
@@ -47,13 +39,11 @@ abstract class IrWhenBase(
 }
 
 class IrWhenImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
     override val origin: IrStatementOrigin? = null
-) :
+) : IrWhenBase() {
-    IrWhenBase(startOffset, endOffset, type) {
-
     constructor(
         startOffset: Int,
         endOffset: Int,
@@ -68,14 +58,11 @@ class IrWhenImpl(
 }
 
 open class IrBranchImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
     override var condition: IrExpression,
     override var result: IrExpression
-) :
+) : IrElementBase(), IrBranch {
-    IrElementBase(startOffset, endOffset),
-    IrBranch {
-
     constructor(condition: IrExpression, result: IrExpression) :
             this(condition.startOffset, condition.endOffset, condition, result)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrWhileLoopImpl.kt

@@ -23,14 +23,11 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
 class IrWhileLoopImpl(
-    startOffset: Int,
+    override val startOffset: Int,
-    endOffset: Int,
+    override val endOffset: Int,
-    type: IrType,
+    override val type: IrType,
-    origin: IrStatementOrigin?
+    override val origin: IrStatementOrigin?,
-) :
+) : IrLoopBase(), IrWhileLoop {
-    IrLoopBase(startOffset, endOffset, type, origin),
-    IrWhileLoop {
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitWhileLoop(this, data)
     }
@@ -44,4 +41,4 @@ class IrWhileLoopImpl(
         condition = condition.transform(transformer, data)
         body = body?.transform(transformer, data)
     }
-}
+}