Minor: reformat

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.resolve.DescriptorFactory
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.PropertyImportedFromObject
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
-import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
@@ -102,8 +101,7 @@ class PropertyReferenceCodegen(
     override fun generateBody() {
         if (JvmCodegenUtil.isConst(closure)) {
             generateConstInstance(asmType, wrapperMethod.returnType)
-        }
+        } else {
-        else {
             AsmUtil.genClosureFields(closure, v, typeMapper)
         }
 
@@ -135,8 +133,7 @@ class PropertyReferenceCodegen(
                 assert(!shouldHaveBoundReferenceReceiver) { "No bound reference receiver in constructor parameters: $constructorArgs" }
                 load(0, OBJECT_TYPE)
                 invokespecial(superAsmType.internalName, "<init>", "()V", false)
-            }
+            } else {
-            else {
                 val (receiverIndex, receiverType) = receiverIndexAndType
                 load(0, OBJECT_TYPE)
                 loadBoundReferenceReceiverParameter(receiverIndex, receiverType)
@@ -148,16 +145,44 @@ class PropertyReferenceCodegen(
     private fun generateAccessors() {
         val getFunction = findGetFunction(localVariableDescriptorForReference)
         val getImpl = createFakeOpenDescriptor(getFunction, classDescriptor)
-        functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, getImpl, PropertyReferenceGenerationStrategy(true, getFunction, target, asmType, receiverType, element, state, false))
+        functionCodegen.generateMethod(
+            JvmDeclarationOrigin.NO_ORIGIN,
+            getImpl,
+            PropertyReferenceGenerationStrategy(
+                true,
+                getFunction,
+                target,
+                asmType,
+                receiverType,
+                element,
+                state,
+                false
+            )
+        )
 
         if (!ReflectionTypes.isNumberedKMutablePropertyType(localVariableDescriptorForReference.type)) return
-        val setFunction = localVariableDescriptorForReference.type.memberScope.getContributedFunctions(OperatorNameConventions.SET, NoLookupLocation.FROM_BACKEND).single()
+        val setFunction = localVariableDescriptorForReference.type.memberScope.getContributedFunctions(
+            OperatorNameConventions.SET,
+            NoLookupLocation.FROM_BACKEND
+        ).single()
         val setImpl = createFakeOpenDescriptor(setFunction, classDescriptor)
-        functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, setImpl, PropertyReferenceGenerationStrategy(false, setFunction, target, asmType, receiverType, element, state, false))
+        functionCodegen.generateMethod(
+            JvmDeclarationOrigin.NO_ORIGIN,
+            setImpl,
+            PropertyReferenceGenerationStrategy(
+                false,
+                setFunction,
+                target,
+                asmType,
+                receiverType,
+                element,
+                state,
+                false
+            )
+        )
     }
 
 
-
     private fun generateMethod(debugString: String, access: Int, method: Method, generate: InstructionAdapter.() -> Unit) {
         v.generateMethod(debugString, access, method, element, JvmDeclarationOrigin.NO_ORIGIN, state, generate)
     }
@@ -171,8 +196,7 @@ class PropertyReferenceCodegen(
             if (JvmCodegenUtil.isConst(closure)) {
                 assert(receiverValue == null) { "No receiver expected for unbound property reference: $classDescriptor" }
                 iv.getstatic(asmType.internalName, JvmAbi.INSTANCE_FIELD, wrapperMethod.returnType.descriptor)
-            }
+            } else {
-            else {
                 assert(receiverValue != null) { "Receiver expected for bound property reference: $classDescriptor" }
                 iv.anew(asmType)
                 iv.dup()
@@ -215,8 +239,7 @@ class PropertyReferenceCodegen(
             val accessor = when (callable) {
                 is FunctionDescriptor -> callable
                 is VariableDescriptorWithAccessors ->
-                    callable.getter ?:
+                    callable.getter ?: DescriptorFactory.createDefaultGetter(callable as PropertyDescriptor, Annotations.EMPTY).apply {
-                    DescriptorFactory.createDefaultGetter(callable as PropertyDescriptor, Annotations.EMPTY).apply {
                         initialize(callable.type)
                     }
                 else -> error("Unsupported callable reference: $callable")
@@ -251,7 +274,11 @@ class PropertyReferenceCodegen(
         }
 
         @JvmStatic
-        fun findGetFunction(localVariableDescriptorForReference: VariableDescriptor) = localVariableDescriptorForReference.type.memberScope.getContributedFunctions(OperatorNameConventions.GET, NoLookupLocation.FROM_BACKEND).single()
+        fun findGetFunction(localVariableDescriptorForReference: VariableDescriptor) =
+            localVariableDescriptorForReference.type.memberScope.getContributedFunctions(
+                OperatorNameConventions.GET,
+                NoLookupLocation.FROM_BACKEND
+            ).single()
     }
 
     class PropertyReferenceGenerationStrategy(
@@ -276,11 +303,11 @@ class PropertyReferenceCodegen(
             }
 
             if (receiverType != null) {
-                val expectedReceiver = target.extensionReceiverParameter?.type ?: (target.containingDeclaration as? ClassDescriptor)?.defaultType
+                val expectedReceiver =
+                    target.extensionReceiverParameter?.type ?: (target.containingDeclaration as? ClassDescriptor)?.defaultType
                 val expectedReceiverType = if (expectedReceiver != null) typeMapper.mapType(expectedReceiver) else receiverType
                 capturedBoundReferenceReceiver(asmType, expectedReceiverType, isInliningStrategy).put(expectedReceiverType, v)
-            }
+            } else {
-            else {
                 val receivers = originalFunctionDesc.valueParameters.dropLast(if (isGetter) 0 else 1)
                 receivers.forEachIndexed { i, valueParameterDescriptor ->
                     StackValue.local(i + 1, OBJECT_TYPE).put(typeMapper.mapType(valueParameterDescriptor), valueParameterDescriptor.type, v)
@@ -289,15 +316,14 @@ class PropertyReferenceCodegen(
 
             val value = if (target is LocalVariableDescriptor) {
                 codegen.findLocalOrCapturedValue(target)!!
-            }
+            } else {
-            else
                 codegen.intermediateValueForProperty(target as PropertyDescriptor, false, null, StackValue.none())
+            }
 
             codegen.markStartLineNumber(expression)
             if (isGetter) {
                 value.put(OBJECT_TYPE, v)
-            }
+            } else {
-            else {
                 val functionDescriptor = codegen.context.functionDescriptor
                 value.store(StackValue.local(codegen.frameMap.getIndex(functionDescriptor.valueParameters.last()), OBJECT_TYPE), v)
             }