From 2b5cb0f722e84b3e5b3f7dfd2318a32877846cec Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Fri, 16 Sep 2016 13:57:16 +0300 Subject: [PATCH] Make statement containers mutable. --- .../psi2ir/builders/ExpressionHelpers.kt | 4 +-- .../kotlin/psi2ir/builders/IrBuilder.kt | 4 +-- .../kotlin/psi2ir/generators/BodyGenerator.kt | 26 +++++++++---------- .../BranchingExpressionGenerator.kt | 6 ++--- .../kotlin/psi2ir/generators/CallGenerator.kt | 2 +- .../psi2ir/generators/ClassGenerator.kt | 4 +-- .../psi2ir/generators/LocalClassGenerator.kt | 4 +-- .../generators/LocalFunctionGenerator.kt | 8 +++--- .../generators/LoopExpressionGenerator.kt | 8 +++--- .../psi2ir/generators/PropertyGenerator.kt | 8 +++--- .../psi2ir/generators/StatementGenerator.kt | 4 +-- .../intermediate/RematerializableValue.kt | 2 +- .../psi2ir/intermediate/SafeCallReceiver.kt | 4 +-- .../intermediate/SimplePropertyLValue.kt | 2 +- .../transformations/InsertImplicitCasts.kt | 2 +- .../jetbrains/kotlin/ir/expressions/IrBody.kt | 6 +---- .../ir/expressions/impl/IrBlockBodyImpl.kt | 12 --------- .../kotlin/ir/expressions/impl/IrBlockImpl.kt | 8 +++--- .../ir/expressions/impl/IrCompositeImpl.kt | 2 +- .../impl/IrContainerExpressionBase.kt | 12 --------- 20 files changed, 50 insertions(+), 78 deletions(-) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/ExpressionHelpers.kt index e23273b4941..3b750d15330 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/ExpressionHelpers.kt +++ b/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.addStatement(irResult) + irBlock.statements.add(irTemporary) + irBlock.statements.add(irResult) return irBlock } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/IrBuilder.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/IrBuilder.kt index 60cec914c87..0e5d566e7d4 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/builders/IrBuilder.kt +++ b/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 } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt index ddfe7020cd2..a8b704190bf 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt +++ b/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 } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BranchingExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BranchingExpressionGenerator.kt index 0ba9b03b193..bf143fd382a 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BranchingExpressionGenerator.kt +++ b/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.addStatement(irWhen) + irBlock.statements.add(irSubject) + irBlock.statements.add(irWhen) return irBlock } } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt index b9c939a8029..4f7ed7f2ba4 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt +++ b/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 } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt index 13213bd5871..2c26352e176 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt +++ b/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 } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt index 3b7dbd23b2a..9ee504c9adb 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt +++ b/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 diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalFunctionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalFunctionGenerator.kt index 56d04d2a3ff..40279000f07 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalFunctionGenerator.kt +++ b/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 diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt index 9c280bd33bf..12b5bfaf837 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LoopExpressionGenerator.kt +++ b/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 diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt index 5b00c82e3ac..cbe361b9186 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/PropertyGenerator.kt +++ b/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, - IrGetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver))) + irBody.statements.add(IrReturnImpl(ktProperty.startOffset, ktProperty.endOffset, context.builtIns.nothingType, getter, + 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, - IrGetVariableImpl(ktProperty.startOffset, ktProperty.endOffset, setterParameter))) + irBody.statements.add(IrSetFieldImpl(ktProperty.startOffset, ktProperty.endOffset, property, receiver, + IrGetVariableImpl(ktProperty.startOffset, ktProperty.endOffset, setterParameter))) return irBody } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt index 4df1f35afda..97ed690a6b7 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt +++ b/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 diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/RematerializableValue.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/RematerializableValue.kt index 3dd9fd3f869..0896b9f3fee 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/RematerializableValue.kt +++ b/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) } \ No newline at end of file diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SafeCallReceiver.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SafeCallReceiver.kt index 8a9ea436a05..8a5e4218be7 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SafeCallReceiver.kt +++ b/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 } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SimplePropertyLValue.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SimplePropertyLValue.kt index b8abdacd62a..0049121a369 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/SimplePropertyLValue.kt +++ b/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 } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt index fb031b423e6..2ef3f9cc201 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt @@ -65,7 +65,7 @@ class InsertImplicitCasts(val builtIns: KotlinBuiltIns): IrElementTransformer - - fun addStatement(statement: IrStatement) - fun addAll(statements: Collection) - fun putStatement(index: Int, statement: IrStatement) + val statements: MutableList } interface IrBlockBody : IrBody, IrStatementContainer diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt index 7f4f81542f4..97d0aeded7f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt +++ b/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 = ArrayList() - override fun addStatement(statement: IrStatement) { - statements.add(statement) - } - - override fun addAll(statements: Collection) { - this.statements.addAll(statements) - } - - override fun putStatement(index: Int, statement: IrStatement) { - statements[index] = statement - } - override fun accept(visitor: IrElementVisitor, data: D): R { return visitor.visitBlockBody(this, data) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt index a29fc15c590..0b52fc8b656 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockImpl.kt +++ b/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) : this(startOffset, endOffset, type, origin) { - addAll(statements) + this.statements.addAll(statements) } override fun accept(visitor: IrElementVisitor, 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) } } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCompositeImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCompositeImpl.kt index 019163d2ed4..755d6d63921 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCompositeImpl.kt +++ b/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) : this(startOffset, endOffset, type, origin) { - addAll(statements) + this.statements.addAll(statements) } override fun accept(visitor: IrElementVisitor, data: D): R = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrContainerExpressionBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrContainerExpressionBase.kt index 4d4dfbf655e..ee657edff8e 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrContainerExpressionBase.kt +++ b/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 = ArrayList(2) - override fun addStatement(statement: IrStatement) { - statements.add(statement) - } - - override fun addAll(statements: Collection) { - this.statements.addAll(statements) - } - - override fun putStatement(index: Int, statement: IrStatement) { - statements[index] = statement - } - override fun acceptChildren(visitor: IrElementVisitor, data: D) { statements.forEach { it.accept(visitor, data) } }