diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
index 7e97f7a1339..f1202c3d07e 100644
--- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
+++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/InnerClassesLowering.kt
@@ -52,11 +52,13 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
         private fun createOuterThisField() {
             outerThisFieldDescriptor = context.descriptorsFactory.getOuterThisFieldDescriptor(irClass.descriptor)
 
-            irClass.declarations.add(IrFieldImpl(
-                irClass.startOffset, irClass.endOffset,
-                FIELD_FOR_OUTER_THIS,
-                outerThisFieldDescriptor
-            ))
+            irClass.declarations.add(
+                IrFieldImpl(
+                    irClass.startOffset, irClass.endOffset,
+                    FIELD_FOR_OUTER_THIS,
+                    outerThisFieldDescriptor
+                )
+            )
         }
 
         private fun lowerConstructors() {
@@ -100,14 +102,13 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
                         IrGetValueImpl(startOffset, endOffset, outerThisValueParameter)
                     )
                 )
-            }
-            else {
+            } else {
                 // Delegating constructor: invoke old constructor with dispatch receiver '$outer'
-                val delegatingConstructorCall = (blockBody.statements.find { it is IrDelegatingConstructorCall } ?:
-                                                 throw AssertionError("Delegating constructor call expected: ${irConstructor.dump()}")
-                                                ) as IrDelegatingConstructorCall
+                val delegatingConstructorCall = (blockBody.statements.find { it is IrDelegatingConstructorCall }
+                        ?: throw AssertionError("Delegating constructor call expected: ${irConstructor.dump()}")
+                        ) as IrDelegatingConstructorCall
                 delegatingConstructorCall.dispatchReceiver = IrGetValueImpl(
-                        delegatingConstructorCall.startOffset, delegatingConstructorCall.endOffset, outerThisValueParameter
+                    delegatingConstructorCall.startOffset, delegatingConstructorCall.endOffset, outerThisValueParameter
                 )
             }
 
@@ -124,14 +125,13 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
 
 
                 override fun visitClass(declaration: IrClass): IrStatement =
-                        //TODO: maybe add another transformer that skips specified elements
-                        declaration
+                //TODO: maybe add another transformer that skips specified elements
+                    declaration
 
                 override fun visitGetValue(expression: IrGetValue): IrExpression {
                     expression.transformChildrenVoid(this)
 
-                    val implicitThisClass = expression.descriptor.getClassDescriptorForImplicitThis() ?:
-                                            return expression
+                    val implicitThisClass = expression.descriptor.getClassDescriptorForImplicitThis() ?: return expression
 
                     if (implicitThisClass == classDescriptor) return expression
 
@@ -154,7 +154,7 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
 
                         val outer = innerClass.containingDeclaration
                         innerClass = outer as? ClassDescriptor ?:
-                                     throw AssertionError("Unexpected containing declaration for inner class $innerClass: $outer")
+                                throw AssertionError("Unexpected containing declaration for inner class $innerClass: $outer")
                     }
 
                     return irThis
@@ -186,13 +186,13 @@ class InnerClassConstructorCallsLowering(val context: BackendContext) : BodyLowe
 
                 val newCallee = context.descriptorsFactory.getInnerClassConstructorWithOuterThisParameter(callee)
                 val newCall = IrCallImpl(
-                        expression.startOffset, expression.endOffset, newCallee, newCallee.descriptor,
-                        null, // TODO type arguments map
-                        expression.origin
+                    expression.startOffset, expression.endOffset, newCallee, newCallee.descriptor,
+                    null, // TODO type arguments map
+                    expression.origin
                 )
 
                 newCall.putValueArgument(0, dispatchReceiver)
-                for (i in 1 .. newCallee.descriptor.valueParameters.lastIndex) {
+                for (i in 1..newCallee.descriptor.valueParameters.lastIndex) {
                     newCall.putValueArgument(i, expression.getValueArgument(i - 1))
                 }
 
@@ -208,12 +208,12 @@ class InnerClassConstructorCallsLowering(val context: BackendContext) : BodyLowe
 
                 val newCallee = context.descriptorsFactory.getInnerClassConstructorWithOuterThisParameter(callee)
                 val newCall = IrDelegatingConstructorCallImpl(
-                        expression.startOffset, expression.endOffset, newCallee, newCallee.descriptor,
-                        null // TODO type arguments map
+                    expression.startOffset, expression.endOffset, newCallee, newCallee.descriptor,
+                    null // TODO type arguments map
                 )
 
                 newCall.putValueArgument(0, dispatchReceiver)
-                for (i in 1 .. newCallee.descriptor.valueParameters.lastIndex) {
+                for (i in 1..newCallee.descriptor.valueParameters.lastIndex) {
                     newCall.putValueArgument(i, expression.getValueArgument(i - 1))
                 }
 
diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
index 6aa5cef5b32..9410f419334 100644
--- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
+++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt
@@ -51,7 +51,7 @@ import java.util.*
 
 open class ExpressionInfo(val expression: IrExpression)
 
-class LoopInfo(val loop: IrLoop, val continueLabel: Label, val breakLabel: Label): ExpressionInfo(loop)
+class LoopInfo(val loop: IrLoop, val continueLabel: Label, val breakLabel: Label) : ExpressionInfo(loop)
 
 class TryInfo(val tryBlock: IrTry) : ExpressionInfo(tryBlock) {
     val gaps = mutableListOf<Label>()
@@ -71,7 +71,7 @@ class BlockInfo private constructor(val parent: BlockInfo?) {
     }
 
     fun removeInfo(info: ExpressionInfo) {
-        assert (peek() == info)
+        assert(peek() == info)
         pop()
     }
 
@@ -92,10 +92,10 @@ class VariableInfo(val declaration: IrVariable, val index: Int, val type: Type,
 
 @Suppress("IMPLICIT_CAST_TO_ANY")
 class ExpressionCodegen(
-        val irFunction: IrFunction,
-        val frame: IrFrameMap,
-        val mv: InstructionAdapter,
-        val classCodegen: ClassCodegen
+    val irFunction: IrFunction,
+    val frame: IrFrameMap,
+    val mv: InstructionAdapter,
+    val classCodegen: ClassCodegen
 ) : IrElementVisitor<StackValue, BlockInfo>, BaseExpressionCodegen {
 
     /*TODO*/
@@ -118,8 +118,7 @@ class ExpressionCodegen(
         if (returnType == Type.VOID_TYPE) {
             //for implicit return
             mv.areturn(Type.VOID_TYPE)
-        }
-        else if (irFunction.body is IrExpressionBody) {
+        } else if (irFunction.body is IrExpressionBody) {
             mv.areturn(returnType)
         }
         writeLocalVariablesInTable(info)
@@ -127,8 +126,7 @@ class ExpressionCodegen(
     }
 
     override fun visitBlockBody(body: IrBlockBody, data: BlockInfo): StackValue {
-        return body.statements.fold(none()) {
-            _, exp ->
+        return body.statements.fold(none()) { _, exp ->
             exp.accept(this, data)
         }
     }
@@ -138,8 +136,7 @@ class ExpressionCodegen(
         return super.visitBlock(expression, info).apply {
             if (!expression.isTransparentScope) {
                 writeLocalVariablesInTable(info)
-            }
-            else {
+            } else {
                 info.variables.forEach {
                     data.variables.add(it)
                 }
@@ -159,8 +156,7 @@ class ExpressionCodegen(
     }
 
     override fun visitContainerExpression(expression: IrContainerExpression, data: BlockInfo): StackValue {
-        val result = expression.statements.fold(none()) {
-            _, exp ->
+        val result = expression.statements.fold(none()) { _, exp ->
             //coerceNotToUnit(r.type, Type.VOID_TYPE)
             exp.accept(this, data)
         }
@@ -192,7 +188,7 @@ class ExpressionCodegen(
     }
 
     fun generateNewArray(
-            expression: IrCall, data: BlockInfo
+        expression: IrCall, data: BlockInfo
     ): StackValue {
         val args = expression.descriptor.valueParameters
         assert(args.size == 1 || args.size == 2) { "Unknown constructor called: " + args.size + " arguments" }
@@ -223,9 +219,9 @@ class ExpressionCodegen(
         val receiver = expression.dispatchReceiver
         receiver?.apply {
             callGenerator.genValueAndPut(
-                    null, this,
-                    if (isSuperCall) receiver.asmType else callable.dispatchReceiverType!!,
-                    -1, this@ExpressionCodegen, data
+                null, this,
+                if (isSuperCall) receiver.asmType else callable.dispatchReceiverType!!,
+                -1, this@ExpressionCodegen, data
             )
         }
 
@@ -243,7 +239,13 @@ class ExpressionCodegen(
                     callGenerator.genValueAndPut(parameterDescriptor, arg, parameterType, i, this@ExpressionCodegen, data)
                 }
                 parameterDescriptor.hasDefaultValue() -> {
-                    callGenerator.putValueIfNeeded(parameterType, StackValue.createDefaultValue(parameterType), ValueKind.DEFAULT_PARAMETER, i, this@ExpressionCodegen)
+                    callGenerator.putValueIfNeeded(
+                        parameterType,
+                        StackValue.createDefaultValue(parameterType),
+                        ValueKind.DEFAULT_PARAMETER,
+                        i,
+                        this@ExpressionCodegen
+                    )
                     defaultMask.mark(i)
                 }
                 else -> {
@@ -254,21 +256,22 @@ class ExpressionCodegen(
                     // while its lower bound may be Nothing-typed after approximation
                     val type = typeMapper.mapType(parameterDescriptor.type.upperIfFlexible())
                     callGenerator.putValueIfNeeded(
-                            parameterType,
-                            StackValue.operation(type) {
-                                it.aconst(0)
-                                it.newarray(correctElementType(type))
-                            },
-                            ValueKind.GENERAL_VARARG, i, this@ExpressionCodegen)
+                        parameterType,
+                        StackValue.operation(type) {
+                            it.aconst(0)
+                            it.newarray(correctElementType(type))
+                        },
+                        ValueKind.GENERAL_VARARG, i, this@ExpressionCodegen
+                    )
                 }
             }
         }
 
         callGenerator.genCall(
-                callable,
-                defaultMask.generateOnStackIfNeeded(callGenerator, expression.descriptor is ConstructorDescriptor, this),
-                this,
-                expression
+            callable,
+            defaultMask.generateOnStackIfNeeded(callGenerator, expression.descriptor is ConstructorDescriptor, this),
+            this,
+            expression
         )
 
         val returnType = expression.descriptor.returnType
@@ -302,10 +305,10 @@ class ExpressionCodegen(
         }
 
         val info = VariableInfo(
-                declaration,
-                index,
-                varType,
-                markNewLabel()
+            declaration,
+            index,
+            varType,
+            markNewLabel()
         )
         data.variables.add(info)
 
@@ -435,8 +438,7 @@ class ExpressionCodegen(
                 if (arrayOfReferences) {
                     mv.checkcast(type)
                 }
-            }
-            else {
+            } else {
                 val owner: String
                 val addDescriptor: String
                 val toArrayDescriptor: String
@@ -444,9 +446,9 @@ class ExpressionCodegen(
                     owner = "kotlin/jvm/internal/SpreadBuilder"
                     addDescriptor = "(Ljava/lang/Object;)V"
                     toArrayDescriptor = "([Ljava/lang/Object;)[Ljava/lang/Object;"
-                }
-                else {
-                    val spreadBuilderClassName = AsmUtil.asmPrimitiveTypeToLangPrimitiveType(elementType)!!.typeName.identifier + "SpreadBuilder"
+                } else {
+                    val spreadBuilderClassName =
+                        AsmUtil.asmPrimitiveTypeToLangPrimitiveType(elementType)!!.typeName.identifier + "SpreadBuilder"
                     owner = "kotlin/jvm/internal/" + spreadBuilderClassName
                     addDescriptor = "(" + elementType.descriptor + ")V"
                     toArrayDescriptor = "()" + type.descriptor
@@ -461,8 +463,7 @@ class ExpressionCodegen(
                     if (argument is IrSpreadElement) {
                         gen(argument.expression, OBJECT_TYPE, data)
                         mv.invokevirtual(owner, "addSpread", "(Ljava/lang/Object;)V", false)
-                    }
-                    else {
+                    } else {
                         gen(argument, elementType, data)
                         mv.invokevirtual(owner, "add", addDescriptor, false)
                     }
@@ -473,22 +474,25 @@ class ExpressionCodegen(
                     newArrayInstruction(outType)
                     mv.invokevirtual(owner, "toArray", toArrayDescriptor, false)
                     mv.checkcast(type)
-                }
-                else {
+                } else {
                     mv.invokevirtual(owner, "toArray", toArrayDescriptor, false)
                 }
             }
-        }
-        else {
+        } else {
             mv.iconst(size)
             newArrayInstruction(expression.type)
             val elementKotlinType = outType.constructor.builtIns.getArrayElementType(outType)
-            for ((i, element)  in expression.elements.withIndex()) {
+            for ((i, element) in expression.elements.withIndex()) {
                 mv.dup()
                 StackValue.constant(i, Type.INT_TYPE).put(Type.INT_TYPE, mv)
                 val rightSide = gen(element, elementType, data)
                 StackValue
-                    .arrayElement(elementType, elementKotlinType, StackValue.onStack(elementType, outType), StackValue.onStack(Type.INT_TYPE))
+                    .arrayElement(
+                        elementType,
+                        elementKotlinType,
+                        StackValue.onStack(elementType, outType),
+                        StackValue.onStack(Type.INT_TYPE)
+                    )
                     .store(rightSide, mv)
             }
         }
@@ -503,8 +507,7 @@ class ExpressionCodegen(
 //                    ReifiedTypeInliner.OperationKind.NEW_ARRAY
 //            )
             mv.newarray(boxType(elementJetType.asmType))
-        }
-        else {
+        } else {
             val type = typeMapper.mapType(arrayType)
             mv.newarray(correctElementType(type))
         }
@@ -602,8 +605,10 @@ class ExpressionCodegen(
                 gen(expression.argument, asmType, data)
                 mv.dup()
                 mv.visitLdcInsn("TODO provide message for IMPLICIT_NOTNULL") /*TODO*/
-                mv.invokestatic("kotlin/jvm/internal/Intrinsics", "checkExpressionValueIsNotNull",
-                               "(Ljava/lang/Object;Ljava/lang/String;)V", false)
+                mv.invokestatic(
+                    "kotlin/jvm/internal/Intrinsics", "checkExpressionValueIsNotNull",
+                    "(Ljava/lang/Object;Ljava/lang/String;)V", false
+                )
             }
 
             IrTypeOperator.IMPLICIT_INTEGER_COERCION -> {
@@ -663,9 +668,9 @@ class ExpressionCodegen(
     }
 
     private fun generateBreakOrContinueExpression(
-            expression: IrBreakContinue,
-            afterBreakContinueLabel: Label,
-            data: BlockInfo
+        expression: IrBreakContinue,
+        afterBreakContinueLabel: Label,
+        data: BlockInfo
     ) {
         if (data.isEmpty()) {
             throw UnsupportedOperationException("Target label for break/continue not found")
@@ -732,7 +737,7 @@ class ExpressionCodegen(
         val tryRegions = getCurrentTryIntervals(tryInfo, tryBlockStart, tryBlockEnd)
 
         val tryCatchBlockEnd = Label()
-        genFinallyBlockOrGoto(tryInfo,  tryCatchBlockEnd, null, data)
+        genFinallyBlockOrGoto(tryInfo, tryCatchBlockEnd, null, data)
 
         val catches = aTry.catches
         for (clause in catches) {
@@ -749,10 +754,17 @@ class ExpressionCodegen(
 
             val clauseEnd = markNewLabel()
 
-            mv.visitLocalVariable(descriptor.name.asString(), descriptorType.descriptor, null, clauseStart, clauseEnd,
-                                 index)
+            mv.visitLocalVariable(
+                descriptor.name.asString(), descriptorType.descriptor, null, clauseStart, clauseEnd,
+                index
+            )
 
-            genFinallyBlockOrGoto(tryInfo, if (clause != catches.last() || finallyExpression != null) tryCatchBlockEnd else null, null, data)
+            genFinallyBlockOrGoto(
+                tryInfo,
+                if (clause != catches.last() || finallyExpression != null) tryCatchBlockEnd else null,
+                null,
+                data
+            )
 
             generateExceptionTable(clauseStart, tryRegions, descriptorType.internalName)
         }
@@ -790,9 +802,9 @@ class ExpressionCodegen(
     }
 
     private fun getCurrentTryIntervals(
-            finallyBlockStackElement: TryInfo?,
-            blockStart: Label,
-            blockEnd: Label
+        finallyBlockStackElement: TryInfo?,
+        blockStart: Label,
+        blockEnd: Label
     ): List<Label> {
         val gapsInBlock = if (finallyBlockStackElement != null) ArrayList<Label>(finallyBlockStackElement.gaps) else emptyList<Label>()
         assert(gapsInBlock.size % 2 == 0)
@@ -814,10 +826,10 @@ class ExpressionCodegen(
     }
 
     private fun genFinallyBlockOrGoto(
-            tryInfo: TryInfo?,
-            tryCatchBlockEnd: Label?,
-            afterJumpLabel: Label?,
-            data: BlockInfo
+        tryInfo: TryInfo?,
+        tryCatchBlockEnd: Label?,
+        afterJumpLabel: Label?,
+        data: BlockInfo
     ) {
         if (tryInfo != null) {
             assert(tryInfo.gaps.size % 2 == 0) { "Finally block gaps are inconsistent" }
@@ -857,8 +869,7 @@ class ExpressionCodegen(
                 doFinallyOnReturn(afterReturnLabel, data)
                 localForReturnValue.put(returnType, mv)
                 frame.leaveTemp(returnType)
-            }
-            else {
+            } else {
                 doFinallyOnReturn(afterReturnLabel, data)
             }
         }
@@ -906,8 +917,7 @@ class ExpressionCodegen(
         if (classReference !is IrClassReference /* && DescriptorUtils.isObjectQualifier(classReference.descriptor)*/) {
             assert(classReference is IrGetClass)
             JavaClassProperty.generateImpl(mv, gen((classReference as IrGetClass).argument, data))
-        }
-        else {
+        } else {
             val type = classReference.classType
             if (TypeUtils.isTypeParameter(type)) {
                 assert(TypeUtils.isReifiedTypeParameter(type)) { "Non-reified type parameter under ::class should be rejected by type checker: " + type }
@@ -940,7 +950,11 @@ class ExpressionCodegen(
     private fun resolveToCallable(irCall: IrMemberAccessExpression, isSuper: Boolean): Callable {
         val intrinsic = intrinsics.getIntrinsic(irCall.descriptor.original as CallableMemberDescriptor)
         if (intrinsic != null) {
-            return intrinsic.toCallable(irCall, typeMapper.mapSignatureSkipGeneric(irCall.descriptor as FunctionDescriptor), classCodegen.context)
+            return intrinsic.toCallable(
+                irCall,
+                typeMapper.mapSignatureSkipGeneric(irCall.descriptor as FunctionDescriptor),
+                classCodegen.context
+            )
         }
 
         var descriptor = irCall.descriptor
@@ -955,8 +969,7 @@ class ExpressionCodegen(
             val propertyDescriptor = JvmCodegenUtil.getDirectMember(descriptor) as SyntheticJavaPropertyDescriptor
             descriptor = if (descriptor is PropertyGetterDescriptor) {
                 propertyDescriptor.getMethod
-            }
-            else {
+            } else {
                 propertyDescriptor.setMethod!!
             }
         }
@@ -971,10 +984,10 @@ class ExpressionCodegen(
 
 
     private fun getOrCreateCallGenerator(
-            descriptor: CallableDescriptor,
-            element: IrMemberAccessExpression?,
-            typeParameterMappings: TypeParameterMappings?,
-            isDefaultCompilation: Boolean
+        descriptor: CallableDescriptor,
+        element: IrMemberAccessExpression?,
+        typeParameterMappings: TypeParameterMappings?,
+        isDefaultCompilation: Boolean
     ): IrCallGenerator {
         if (element == null) return IrCallGenerator.DefaultCallGenerator
 
@@ -987,13 +1000,15 @@ class ExpressionCodegen(
         val original = unwrapInitialSignatureDescriptor(DescriptorUtils.unwrapFakeOverride(descriptor.original as FunctionDescriptor))
         return if (isDefaultCompilation) {
             TODO()
-        }
-        else {
+        } else {
             IrInlineCodegen(this, state, original, typeParameterMappings!!, IrSourceCompilerForInline(state, element, this))
         }
     }
 
-    internal fun getOrCreateCallGenerator(memberAccessExpression: IrMemberAccessExpression, descriptor: CallableDescriptor): IrCallGenerator {
+    internal fun getOrCreateCallGenerator(
+        memberAccessExpression: IrMemberAccessExpression,
+        descriptor: CallableDescriptor
+    ): IrCallGenerator {
         val typeArguments = descriptor.original.typeParameters.keysToMap { memberAccessExpression.getTypeArgumentOrDefault(it) }
 
         val mappings = TypeParameterMappings()
@@ -1011,12 +1026,11 @@ class ExpressionCodegen(
                 val asmType = typeMapper.mapTypeParameter(approximatedType, signatureWriter)
 
                 mappings.addParameterMappingToType(
-                        key.name.identifier, approximatedType, asmType, signatureWriter.toString(), isReified
+                    key.name.identifier, approximatedType, asmType, signatureWriter.toString(), isReified
                 )
-            }
-            else {
+            } else {
                 mappings.addParameterMappingForFurtherReification(
-                        key.name.identifier, type, typeParameterAndReificationArgument.second, isReified
+                    key.name.identifier, type, typeParameterAndReificationArgument.second, isReified
                 )
             }
         }
@@ -1041,7 +1055,12 @@ class ExpressionCodegen(
         //TODO
     }
 
-    override fun pushClosureOnStack(classDescriptor: ClassDescriptor, putThis: Boolean, callGenerator: CallGenerator, functionReferenceReceiver: StackValue?) {
+    override fun pushClosureOnStack(
+        classDescriptor: ClassDescriptor,
+        putThis: Boolean,
+        callGenerator: CallGenerator,
+        functionReferenceReceiver: StackValue?
+    ) {
         //TODO
     }
 
@@ -1063,7 +1082,13 @@ fun DefaultCallArgs.generateOnStackIfNeeded(callGenerator: IrCallGenerator, isCo
         }
 
         val parameterType = if (isConstructor) AsmTypes.DEFAULT_CONSTRUCTOR_MARKER else AsmTypes.OBJECT_TYPE
-        callGenerator.putValueIfNeeded(parameterType, StackValue.constant(null, parameterType), ValueKind.METHOD_HANDLE_IN_DEFAULT, -1, codegen)
+        callGenerator.putValueIfNeeded(
+            parameterType,
+            StackValue.constant(null, parameterType),
+            ValueKind.METHOD_HANDLE_IN_DEFAULT,
+            -1,
+            codegen
+        )
     }
     return toInts.isNotEmpty()
-}
+}
\ No newline at end of file