Minor. Reformat

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.declarations.add(
+                IrFieldImpl(
                     irClass.startOffset, irClass.endOffset,
                     FIELD_FOR_OUTER_THIS,
                     outerThisFieldDescriptor
-            ))
+                )
+            )
         }
 
         private fun lowerConstructors() {
@@ -100,11 +102,10 @@ 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 } ?:
+                val delegatingConstructorCall = (blockBody.statements.find { it is IrDelegatingConstructorCall }
-                                                 throw AssertionError("Delegating constructor call expected: ${irConstructor.dump()}")
+                        ?: throw AssertionError("Delegating constructor call expected: ${irConstructor.dump()}")
                         ) as IrDelegatingConstructorCall
                 delegatingConstructorCall.dispatchReceiver = IrGetValueImpl(
                     delegatingConstructorCall.startOffset, delegatingConstructorCall.endOffset, outerThisValueParameter
@@ -130,8 +131,7 @@ class InnerClassesLowering(val context: BackendContext) : ClassLoweringPass {
                 override fun visitGetValue(expression: IrGetValue): IrExpression {
                     expression.transformChildrenVoid(this)
 
-                    val implicitThisClass = expression.descriptor.getClassDescriptorForImplicitThis() ?:
+                    val implicitThisClass = expression.descriptor.getClassDescriptorForImplicitThis() ?: return expression
-                                            return expression
 
                     if (implicitThisClass == classDescriptor) return expression
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt

@@ -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()) {
+        return body.statements.fold(none()) { _, exp ->
-            _, 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()) {
+        val result = expression.statements.fold(none()) { _, exp ->
-            _, exp ->
             //coerceNotToUnit(r.type, Type.VOID_TYPE)
             exp.accept(this, 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 -> {
@@ -259,7 +261,8 @@ class ExpressionCodegen(
                             it.aconst(0)
                             it.newarray(correctElementType(type))
                         },
-                            ValueKind.GENERAL_VARARG, i, this@ExpressionCodegen)
+                        ValueKind.GENERAL_VARARG, i, this@ExpressionCodegen
+                    )
                 }
             }
         }
@@ -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 {
-                else {
+                    val spreadBuilderClassName =
-                    val spreadBuilderClassName = AsmUtil.asmPrimitiveTypeToLangPrimitiveType(elementType)!!.typeName.identifier + "SpreadBuilder"
+                        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,13 +474,11 @@ 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)
@@ -488,7 +487,12 @@ class ExpressionCodegen(
                 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",
+                mv.invokestatic(
-                               "(Ljava/lang/Object;Ljava/lang/String;)V", false)
+                    "kotlin/jvm/internal/Intrinsics", "checkExpressionValueIsNotNull",
+                    "(Ljava/lang/Object;Ljava/lang/String;)V", false
+                )
             }
 
             IrTypeOperator.IMPLICIT_INTEGER_COERCION -> {
@@ -749,10 +754,17 @@ class ExpressionCodegen(
 
             val clauseEnd = markNewLabel()
 
-            mv.visitLocalVariable(descriptor.name.asString(), descriptorType.descriptor, null, clauseStart, clauseEnd,
+            mv.visitLocalVariable(
-                                 index)
+                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)
         }
@@ -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!!
             }
         }
@@ -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()
@@ -1013,8 +1028,7 @@ class ExpressionCodegen(
                 mappings.addParameterMappingToType(
                     key.name.identifier, approximatedType, asmType, signatureWriter.toString(), isReified
                 )
-            }
+            } else {
-            else {
                 mappings.addParameterMappingForFurtherReification(
                     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()
 }