Make statement containers mutable.

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/ExpressionHelpers.kt

@@ -37,8 +37,8 @@ inline fun IrBuilderWithScope.irLet(
     val irTemporary = scope.createTemporaryVariable(value, nameHint)
     val irResult = body(irTemporary.descriptor)
     val irBlock = IrBlockImpl(startOffset, endOffset, irResult.type, origin)
-    irBlock.addStatement(irTemporary)
+    irBlock.statements.add(irTemporary)
-    irBlock.addStatement(irResult)
+    irBlock.statements.add(irResult)
     return irBlock
 }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/IrBuilder.kt

@@ -74,7 +74,7 @@ open class IrBlockBodyBuilder(
     }
 
     override fun addStatement(irStatement: IrStatement) {
-        irBlockBody.addStatement(irStatement)
+        irBlockBody.statements.add(irStatement)
     }
 
     override fun doBuild(): IrBlockBody {
@@ -104,7 +104,7 @@ class IrBlockBuilder(
                          (statements.lastOrNull() as? IrExpression)?.type ?:
                          context.builtIns.unitType
         val irBlock = IrBlockImpl(startOffset, endOffset, resultType, origin)
-        irBlock.addAll(statements)
+        irBlock.statements.addAll(statements)
         return irBlock
     }
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt

@@ -74,13 +74,13 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
             val ktBodyStatements = ktBody.statements
             if (ktBodyStatements.isNotEmpty()) {
                 for (ktStatement in ktBodyStatements.dropLast(1)) {
-                    irBlockBody.addStatement(statementGenerator.generateStatement(ktStatement))
+                    irBlockBody.statements.add(statementGenerator.generateStatement(ktStatement))
                 }
                 val ktReturnedValue = ktBodyStatements.last()
                 statementGenerator.generateReturnExpression(ktReturnedValue, irBlockBody)
             }
             else {
-                irBlockBody.addStatement(generateReturnExpression(ktBody.startOffset, ktBody.endOffset, null))
+                irBlockBody.statements.add(generateReturnExpression(ktBody.startOffset, ktBody.endOffset, null))
             }
         }
 
@@ -89,17 +89,17 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
 
     private fun StatementGenerator.generateBlockBodyStatements(irBlockBody: IrBlockBodyImpl, ktBody: KtBlockExpression) {
         for (ktStatement in ktBody.statements) {
-            irBlockBody.addStatement(generateStatement(ktStatement))
+            irBlockBody.statements.add(generateStatement(ktStatement))
         }
     }
 
     private fun StatementGenerator.generateReturnExpression(ktExpression: KtExpression, irBlockBody: IrBlockBodyImpl) {
         val irReturnExpression = generateStatement(ktExpression)
         if (irReturnExpression is IrExpression) {
-            irBlockBody.addStatement(irReturnExpression.wrapWithReturn())
+            irBlockBody.statements.add(irReturnExpression.wrapWithReturn())
         }
         else {
-            irBlockBody.addStatement(irReturnExpression)
+            irBlockBody.statements.add(irReturnExpression)
         }
     }
 
@@ -150,7 +150,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
         val irDelegatingConstructorCall = CallGenerator(statementGenerator).generateDelegatingConstructorCall(
                 ktDelegatingConstructorCall.startOffset, ktDelegatingConstructorCall.endOffset,
                 delegatingConstructorCall)
-        irBlockBody.addStatement(irDelegatingConstructorCall)
+        irBlockBody.statements.add(irDelegatingConstructorCall)
     }
 
     fun createStatementGenerator() = StatementGenerator(this, scope)
@@ -168,7 +168,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
         generateSuperConstructorCall(irBlockBody, ktClassOrObject)
 
         val classDescriptor = (scopeOwner as ConstructorDescriptor).containingDeclaration
-        irBlockBody.addStatement(IrInstanceInitializerCallImpl(ktClassOrObject.startOffset, ktClassOrObject.endOffset, classDescriptor))
+        irBlockBody.statements.add(IrInstanceInitializerCallImpl(ktClassOrObject.startOffset, ktClassOrObject.endOffset, classDescriptor))
 
         return irBlockBody
     }
@@ -179,7 +179,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
         generateDelegatingConstructorCall(irBlockBody, ktConstructor)
 
         val classDescriptor = getOrFail(BindingContext.CONSTRUCTOR, ktConstructor).containingDeclaration
-        irBlockBody.addStatement(IrInstanceInitializerCallImpl(ktConstructor.startOffset, ktConstructor.endOffset, classDescriptor))
+        irBlockBody.statements.add(IrInstanceInitializerCallImpl(ktConstructor.startOffset, ktConstructor.endOffset, classDescriptor))
 
         ktConstructor.bodyExpression?.let { ktBody ->
             createStatementGenerator().generateBlockBodyStatements(irBlockBody, ktBody)
@@ -196,7 +196,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
                 generateEnumSuperConstructorCall(irBlockBody, ktClassOrObject)
             }
             ClassKind.ENUM_ENTRY -> {
-                irBlockBody.addStatement(generateEnumEntrySuperConstructorCall(ktClassOrObject as KtEnumEntry, classDescriptor))
+                irBlockBody.statements.add(generateEnumEntrySuperConstructorCall(ktClassOrObject as KtEnumEntry, classDescriptor))
             }
             else -> {
                 val statementGenerator = createStatementGenerator()
@@ -207,7 +207,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
                             val superConstructorCall = statementGenerator.pregenerateCall(getResolvedCall(ktSuperTypeListEntry)!!)
                             val irSuperConstructorCall = CallGenerator(statementGenerator).generateDelegatingConstructorCall(
                                     ktSuperTypeListEntry.startOffset, ktSuperTypeListEntry.endOffset, superConstructorCall)
-                            irBlockBody.addStatement(irSuperConstructorCall)
+                            irBlockBody.statements.add(irSuperConstructorCall)
                             return
                         }
                     }
@@ -224,12 +224,12 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
 
     private fun generateAnySuperConstructorCAll(irBlockBody: IrBlockBodyImpl, ktElement: KtElement) {
         val anyConstructor = context.builtIns.any.constructors.single()
-        irBlockBody.addStatement(IrDelegatingConstructorCallImpl(ktElement.startOffset, ktElement.endOffset, anyConstructor))
+        irBlockBody.statements.add(IrDelegatingConstructorCallImpl(ktElement.startOffset, ktElement.endOffset, anyConstructor))
     }
 
     private fun generateEnumSuperConstructorCall(irBlockBody: IrBlockBodyImpl, ktElement: KtElement) {
         val enumConstructor = context.builtIns.enum.constructors.single()
-        irBlockBody.addStatement(IrEnumConstructorCallImpl(ktElement.startOffset, ktElement.endOffset, enumConstructor, null))
+        irBlockBody.statements.add(IrEnumConstructorCallImpl(ktElement.startOffset, ktElement.endOffset, enumConstructor, null))
     }
 
     private fun generateEnumEntrySuperConstructorCall(ktEnumEntry: KtEnumEntry, enumEntryDescriptor: ClassDescriptor): IrExpression {
@@ -243,7 +243,7 @@ class BodyGenerator(val scopeOwner: DeclarationDescriptor, override val context:
             createStatementGenerator().generateBlockBodyStatements(irBlockBody, ktBody)
         }
         else {
-            irBlockBody.addStatement(createStatementGenerator().generateStatement(ktBody))
+            irBlockBody.statements.add(createStatementGenerator().generateStatement(ktBody))
         }
         return irBlockBody
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BranchingExpressionGenerator.kt

@@ -110,13 +110,13 @@ class BranchingExpressionGenerator(statementGenerator: StatementGenerator) : Sta
         else {
             if (irWhen.branchesCount == 0) {
                 val irBlock = IrBlockImpl(expression.startOffset, expression.endOffset, context.builtIns.unitType, IrStatementOrigin.WHEN)
-                irBlock.addStatement(irSubject)
+                irBlock.statements.add(irSubject)
                 return irBlock
             }
             else {
                 val irBlock = IrBlockImpl(expression.startOffset, expression.endOffset, irWhen.type, IrStatementOrigin.WHEN)
-                irBlock.addStatement(irSubject)
+                irBlock.statements.add(irSubject)
-                irBlock.addStatement(irWhen)
+                irBlock.statements.add(irWhen)
                 return irBlock
             }
         }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt

@@ -162,7 +162,7 @@ class CallGenerator(statementGenerator: StatementGenerator): StatementGeneratorE
             irCall.putArgument(index, irArgumentValues[valueParameter]?.load())
         }
 
-        irBlock.addStatement(irCall)
+        irBlock.statements.add(irCall)
 
         return irBlock
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

@@ -173,11 +173,11 @@ class ClassGenerator(val declarationGenerator: DeclarationGenerator) : Generator
             IrGetVariableImpl(irDelegate.startOffset, irDelegate.endOffset, delegatedValueParameter)
         }
         if (KotlinBuiltIns.isUnit(returnType) || KotlinBuiltIns.isNothing(returnType)) {
-            irBlockBody.addStatement(irCall)
+            irBlockBody.statements.add(irCall)
         }
         else {
             val irReturn = IrReturnImpl(irDelegate.startOffset, irDelegate.endOffset, context.builtIns.nothingType, delegated, irCall)
-            irBlockBody.addStatement(irReturn)
+            irBlockBody.statements.add(irReturn)
         }
         return irBlockBody
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt

@@ -31,7 +31,7 @@ class LocalClassGenerator(statementGenerator: StatementGenerator): StatementGene
         val irBlock = IrBlockImpl(ktObjectLiteral.startOffset, ktObjectLiteral.endOffset, objectLiteralType, IrStatementOrigin.OBJECT_LITERAL)
 
         val irClass = DeclarationGenerator(statementGenerator.context).generateClassOrObjectDeclaration(ktObjectLiteral.objectDeclaration)
-        irBlock.addStatement(irClass)
+        irBlock.statements.add(irClass)
 
         val objectConstructor = irClass.descriptor.unsubstitutedPrimaryConstructor ?:
                                 throw AssertionError("Object literal should have a primary constructor: ${irClass.descriptor}")
@@ -45,7 +45,7 @@ class LocalClassGenerator(statementGenerator: StatementGenerator): StatementGene
             "Object literal constructor should have no value parameters: $objectConstructor"
         }
 
-        irBlock.addStatement(IrCallImpl(ktObjectLiteral.startOffset, ktObjectLiteral.endOffset, objectLiteralType,
+        irBlock.statements.add(IrCallImpl(ktObjectLiteral.startOffset, ktObjectLiteral.endOffset, objectLiteralType,
                                         objectConstructor, IrStatementOrigin.OBJECT_LITERAL))
 
         return irBlock

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalFunctionGenerator.kt

@@ -38,9 +38,9 @@ class LocalFunctionGenerator(statementGenerator: StatementGenerator) : Statement
 
         val irFun = IrFunctionImpl(ktFun.startOffset, ktFun.endOffset, IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA, lambdaDescriptor)
         irFun.body = BodyGenerator(lambdaDescriptor, statementGenerator.context).generateLambdaBody(ktFun)
-        irBlock.addStatement(irFun)
+        irBlock.statements.add(irFun)
 
-        irBlock.addStatement(IrCallableReferenceImpl(ktLambda.startOffset, ktLambda.endOffset, lambdaExpressionType,
+        irBlock.statements.add(IrCallableReferenceImpl(ktLambda.startOffset, ktLambda.endOffset, lambdaExpressionType,
                                                      lambdaDescriptor, IrStatementOrigin.LAMBDA))
 
         return irBlock
@@ -56,9 +56,9 @@ class LocalFunctionGenerator(statementGenerator: StatementGenerator) : Statement
                 val irBlock = IrBlockImpl(ktFun.startOffset, ktFun.endOffset, funExpressionType, IrStatementOrigin.ANONYMOUS_FUNCTION)
 
                 val irFun = generateFunctionDeclaration(ktFun)
-                irBlock.addStatement(irFun)
+                irBlock.statements.add(irFun)
 
-                irBlock.addStatement(IrCallableReferenceImpl(ktFun.startOffset, ktFun.endOffset, funExpressionType,
+                irBlock.statements.add(IrCallableReferenceImpl(ktFun.startOffset, ktFun.endOffset, funExpressionType,
                                                              irFun.descriptor, IrStatementOrigin.ANONYMOUS_FUNCTION))
 
                 irBlock

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt

@@ -119,12 +119,12 @@ class LoopExpressionGenerator(statementGenerator: StatementGenerator) : Statemen
         val irIteratorCall = callGenerator.generateCall(ktLoopRange, iteratorCall, IrStatementOrigin.FOR_LOOP_ITERATOR)
         val irIterator = scope.createTemporaryVariable(irIteratorCall, "iterator")
         val iteratorValue = VariableLValue(irIterator)
-        irForBlock.addStatement(irIterator)
+        irForBlock.statements.add(irIterator)
 
         val irInnerWhile = IrWhileLoopImpl(ktFor.startOffset, ktFor.endOffset, context.builtIns.unitType, IrStatementOrigin.FOR_LOOP_INNER_WHILE)
         irInnerWhile.label = getLoopLabel(ktFor)
         statementGenerator.bodyGenerator.putLoop(ktFor, irInnerWhile)
-        irForBlock.addStatement(irInnerWhile)
+        irForBlock.statements.add(irInnerWhile)
 
         val hasNextCall = statementGenerator.pregenerateCall(hasNextResolvedCall)
         hasNextCall.setExplicitReceiverValue(iteratorValue)
@@ -145,14 +145,14 @@ class LoopExpressionGenerator(statementGenerator: StatementGenerator) : Statemen
         else {
             scope.createTemporaryVariable(irNextCall, "loop_parameter")
         }
-        irInnerBody.addStatement(irLoopParameter)
+        irInnerBody.statements.add(irLoopParameter)
 
         if (ktLoopDestructuringParameter != null) {
             statementGenerator.declareComponentVariablesInBlock(ktLoopDestructuringParameter, irInnerBody, VariableLValue(irLoopParameter))
         }
 
         if (ktForBody != null) {
-            irInnerBody.addStatement(statementGenerator.generateExpression(ktForBody))
+            irInnerBody.statements.add(statementGenerator.generateExpression(ktForBody))
         }
 
         return irForBlock

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt

@@ -148,8 +148,8 @@ class PropertyGenerator(val declarationGenerator: DeclarationGenerator) : Genera
 
         val receiver = generateReceiverExpressionForDefaultPropertyAccessor(ktProperty, property)
 
-        irBody.addStatement(IrReturnImpl(ktProperty.startOffset, ktProperty.endOffset, context.builtIns.nothingType, getter,
+        irBody.statements.add(IrReturnImpl(ktProperty.startOffset, ktProperty.endOffset, context.builtIns.nothingType, getter,
-                                         IrGetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver)))
+                                           IrGetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver)))
         return irBody
     }
 
@@ -161,8 +161,8 @@ class PropertyGenerator(val declarationGenerator: DeclarationGenerator) : Genera
         val receiver = generateReceiverExpressionForDefaultPropertyAccessor(ktProperty, property)
 
         val setterParameter = setter.valueParameters.single()
-        irBody.addStatement(IrSetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver,
+        irBody.statements.add(IrSetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver,
-                                           IrGetVariableImpl(ktProperty.startOffset, ktProperty.endOffset, setterParameter)))
+                                             IrGetVariableImpl(ktProperty.startOffset, ktProperty.endOffset, setterParameter)))
         return irBody
     }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt

@@ -116,7 +116,7 @@ class StatementGenerator(
                                                              IrStatementOrigin.COMPONENT_N.withIndex(index + 1))
             val irComponentVar = IrVariableImpl(ktEntry.startOffset, ktEntry.endOffset, IrDeclarationOrigin.DEFINED,
                                                 componentVariable, irComponentCall)
-            irBlock.addStatement(irComponentVar)
+            irBlock.statements.add(irComponentVar)
         }
     }
 
@@ -128,7 +128,7 @@ class StatementGenerator(
         val irBlock = IrBlockImpl(expression.startOffset, expression.endOffset, returnType)
 
         expression.statements.forEach {
-            irBlock.addStatement(it.genStmt())
+            irBlock.statements.add(it.genStmt())
         }
 
         return irBlock

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/RematerializableValue.kt

@@ -31,6 +31,6 @@ class RematerializableValue(val irExpression: IrExpressionWithCopy) : Intermedia
 
 fun Scope.createTemporaryVariableInBlock(irExpression: IrExpression, block: IrContainerExpressionBase, nameHint: String? = null): IntermediateValue {
     val temporaryVariable = createTemporaryVariable(irExpression, nameHint)
-    block.addStatement(temporaryVariable)
+    block.statements.add(temporaryVariable)
     return VariableLValue(temporaryVariable)
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SafeCallReceiver.kt

@@ -53,14 +53,14 @@ class SafeCallReceiver(
 
         val irBlock = IrBlockImpl(startOffset, endOffset, resultType, IrStatementOrigin.SAFE_CALL)
 
-        irBlock.addStatement(irTmp)
+        irBlock.statements.add(irTmp)
 
         val irIfThenElse = IrIfThenElseImpl(startOffset, endOffset, resultType,
                                             generator.context.equalsNull(startOffset, endOffset, safeReceiverValue.load()),
                                             generator.context.constNull(startOffset, endOffset),
                                             irResult,
                                             IrStatementOrigin.SAFE_CALL)
-        irBlock.addStatement(irIfThenElse)
+        irBlock.statements.add(irIfThenElse)
 
         return irBlock
     }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SimplePropertyLValue.kt

@@ -82,7 +82,7 @@ class SimplePropertyLValue(
                 val irBlock = IrBlockImpl(startOffset, endOffset, irResultExpression.type, origin)
                 irBlock.addIfNotNull(dispatchReceiverTmp)
                 irBlock.addIfNotNull(extensionReceiverTmp)
-                irBlock.addStatement(irResultExpression)
+                irBlock.statements.add(irResultExpression)
                 irBlock
             }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt

@@ -65,7 +65,7 @@ class InsertImplicitCasts(val builtIns: KotlinBuiltIns): IrElementTransformer<No
 
         val lastStatement = expression.statements.last()
         if (lastStatement is IrExpression) {
-            expression.putStatement(expression.statements.lastIndex, lastStatement.cast(type))
+            expression.statements[expression.statements.lastIndex] = lastStatement.cast(type)
         }
 
         return expression

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrBody.kt

@@ -30,11 +30,7 @@ interface IrExpressionBody : IrBody {
 }
 
 interface IrStatementContainer {
-    val statements: List<IrStatement>
+    val statements: MutableList<IrStatement>
-
-    fun addStatement(statement: IrStatement)
-    fun addAll(statements: Collection<IrStatement>)
-    fun putStatement(index: Int, statement: IrStatement)
 }
 
 interface IrBlockBody : IrBody, IrStatementContainer

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

@@ -25,18 +25,6 @@ import java.util.*
 class IrBlockBodyImpl(startOffset: Int, endOffset: Int) : IrElementBase(startOffset, endOffset), IrBlockBody {
     override val statements: MutableList<IrStatement> = ArrayList()
 
-    override fun addStatement(statement: IrStatement) {
-        statements.add(statement)
-    }
-
-    override fun addAll(statements: Collection<IrStatement>) {
-        this.statements.addAll(statements)
-    }
-
-    override fun putStatement(index: Int, statement: IrStatement) {
-        statements[index] = statement
-    }
-
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitBlockBody(this, data)
     }

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

@@ -27,7 +27,7 @@ class IrBlockImpl(startOffset: Int, endOffset: Int, type: KotlinType, origin: Ir
         IrContainerExpressionBase(startOffset, endOffset, type, origin), IrBlock {
     constructor(startOffset: Int, endOffset: Int, type: KotlinType, origin: IrStatementOrigin?, statements: List<IrStatement>) :
             this(startOffset, endOffset, type, origin) {
-        addAll(statements)
+        this.statements.addAll(statements)
     }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
@@ -45,14 +45,14 @@ class IrBlockImpl(startOffset: Int, endOffset: Int, type: KotlinType, origin: Ir
 }
 
 fun IrBlockImpl.addIfNotNull(statement: IrStatement?) {
-    if (statement != null) addStatement(statement)
+    if (statement != null) statements.add(statement)
 }
 
 fun IrBlockImpl.inlineStatement(statement: IrStatement) {
     if (statement is IrBlock) {
-        addAll(statement.statements)
+        statements.addAll(statement.statements)
     }
     else {
-        addStatement(statement)
+        statements.add(statement)
     }
 }

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

@@ -27,7 +27,7 @@ class IrCompositeImpl(startOffset: Int, endOffset: Int, type: KotlinType, origin
         IrContainerExpressionBase(startOffset, endOffset, type, origin), IrComposite {
     constructor(startOffset: Int, endOffset: Int, type: KotlinType, origin: IrStatementOrigin?, statements: List<IrStatement>) :
             this(startOffset, endOffset, type, origin) {
-        addAll(statements)
+        this.statements.addAll(statements)
     }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =

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

@@ -28,18 +28,6 @@ abstract class IrContainerExpressionBase(startOffset: Int, endOffset: Int, type:
         IrExpressionBase(startOffset, endOffset, type), IrContainerExpression {
     override val statements: MutableList<IrStatement> = ArrayList(2)
 
-    override fun addStatement(statement: IrStatement) {
-        statements.add(statement)
-    }
-
-    override fun addAll(statements: Collection<IrStatement>) {
-        this.statements.addAll(statements)
-    }
-
-    override fun putStatement(index: Int, statement: IrStatement) {
-        statements[index] = statement
-    }
-
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         statements.forEach { it.accept(visitor, data) }
     }