Make statement containers mutable.

2016-09-16 13:57:16 +03:00
parent 4c88ad408f
commit 2b5cb0f722
20 changed files with 50 additions and 78 deletions
@@ -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
 }

@@ -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
    }
 }
@@ -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
    }
@@ -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
            }
        }
@@ -162,7 +162,7 @@ class CallGenerator(statementGenerator: StatementGenerator): StatementGeneratorE
            irCall.putArgument(index, irArgumentValues[valueParameter]?.load())
        }

-        irBlock.addStatement(irCall)
+        irBlock.statements.add(irCall)

        return irBlock
    }
@@ -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
    }
@@ -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
@@ -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
@@ -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
@@ -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
    }

@@ -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
@@ -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)
 }
@@ -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
    }
@@ -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
            }

@@ -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
@@ -30,11 +30,7 @@ interface IrExpressionBody : IrBody {
 }

 interface IrStatementContainer {
-    val statements: List<IrStatement>
-
-    fun addStatement(statement: IrStatement)
-    fun addAll(statements: Collection<IrStatement>)
-    fun putStatement(index: Int, statement: IrStatement)
+    val statements: MutableList<IrStatement>
 }

 interface IrBlockBody : IrBody, IrStatementContainer
@@ -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)
    }
@@ -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)
    }
 }
@@ -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 =
@@ -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) }
    }