More cleanup: lift return / assignment out

core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt

@@ -98,11 +98,11 @@ object DescriptorEquivalenceForOverrides {
 
         // This check is needed when we call areTypeParametersEquivalent() from areCallableMemberDescriptorsEquivalent:
         // if the type parameter owners are, e.g.,  functions, we'll go into infinite recursion here
-        if (aOwner is CallableMemberDescriptor || bOwner is CallableMemberDescriptor) {
-            return equivalentCallables(aOwner, bOwner)
+        return if (aOwner is CallableMemberDescriptor || bOwner is CallableMemberDescriptor) {
+            equivalentCallables(aOwner, bOwner)
         }
         else {
-            return areEquivalent(aOwner, bOwner)
+            areEquivalent(aOwner, bOwner)
         }
     }
 

core/descriptors/src/org/jetbrains/kotlin/types/KotlinType.kt

@@ -85,11 +85,11 @@ abstract class WrappedType : KotlinType() {
     }
 
     override fun toString(): String {
-        if (isComputed()) {
-            return delegate.toString()
+        return if (isComputed()) {
+            delegate.toString()
         }
         else {
-            return "<Not computed yet>"
+            "<Not computed yet>"
         }
     }
 }

core/descriptors/src/org/jetbrains/kotlin/types/checker/NewKotlinTypeChecker.kt

@@ -287,12 +287,7 @@ object NewKotlinTypeChecker : KotlinTypeChecker {
         if (supertypes.size < 2) return supertypes
 
         val allPureSupertypes = supertypes.filter { it.arguments.all { !it.type.isFlexible() } }
-        if (allPureSupertypes.isNotEmpty()) {
-            return allPureSupertypes
-        }
-        else {
-            return supertypes
-        }
+        return if (allPureSupertypes.isNotEmpty()) allPureSupertypes else supertypes
     }
 
     private fun effectiveVariance(declared: Variance, useSite: Variance): Variance? {

core/descriptors/src/org/jetbrains/kotlin/types/checker/utils.kt

@@ -47,16 +47,16 @@ fun findCorrespondingSupertype(
 
             while (currentPathNode != null) {
                 val currentType = currentPathNode.type
-                if (currentType.arguments.any { it.projectionKind != Variance.INVARIANT }) {
-                    substituted = TypeConstructorSubstitution.create(currentType)
-                                        .wrapWithCapturingSubstitution().buildSubstitutor()
-                                        .safeSubstitute(substituted, Variance.INVARIANT)
-                                        .approximate()
+                substituted = if (currentType.arguments.any { it.projectionKind != Variance.INVARIANT }) {
+                    TypeConstructorSubstitution.create(currentType)
+                            .wrapWithCapturingSubstitution().buildSubstitutor()
+                            .safeSubstitute(substituted, Variance.INVARIANT)
+                            .approximate()
                 }
                 else {
-                    substituted = TypeConstructorSubstitution.create(currentType)
-                                        .buildSubstitutor()
-                                        .safeSubstitute(substituted, Variance.INVARIANT)
+                    TypeConstructorSubstitution.create(currentType)
+                            .buildSubstitutor()
+                            .safeSubstitute(substituted, Variance.INVARIANT)
                 }
 
                 isAnyMarkedNullable = isAnyMarkedNullable || currentType.isMarkedNullable

core/reflection.jvm/src/kotlin/reflect/jvm/internal/RuntimeTypeMapper.kt

@@ -105,18 +105,14 @@ internal sealed class JvmPropertySignature {
             val nameResolver: NameResolver,
             val typeTable: TypeTable
     ) : JvmPropertySignature() {
-        private val string: String
-
-        init {
-            if (signature.hasGetter()) {
-                string = nameResolver.getString(signature.getter.name) + nameResolver.getString(signature.getter.desc)
-            }
-            else {
-                val (name, desc) =
-                        JvmProtoBufUtil.getJvmFieldSignature(proto, nameResolver, typeTable) ?:
-                        throw KotlinReflectionInternalError("No field signature for property: $descriptor")
-                string = JvmAbi.getterName(name) + getManglingSuffix() + "()" + desc
-            }
+        private val string: String = if (signature.hasGetter()) {
+            nameResolver.getString(signature.getter.name) + nameResolver.getString(signature.getter.desc)
+        }
+        else {
+            val (name, desc) =
+                    JvmProtoBufUtil.getJvmFieldSignature(proto, nameResolver, typeTable) ?:
+                    throw KotlinReflectionInternalError("No field signature for property: $descriptor")
+            JvmAbi.getterName(name) + getManglingSuffix() + "()" + desc
         }
 
         private fun getManglingSuffix(): String {
@@ -194,11 +190,11 @@ internal object RuntimeTypeMapper {
             }
             is JavaClassConstructorDescriptor -> {
                 val element = (function.source as? JavaSourceElement)?.javaElement
-                when {
+                return when {
                     element is ReflectJavaConstructor ->
-                        return JvmFunctionSignature.JavaConstructor(element.member)
+                        JvmFunctionSignature.JavaConstructor(element.member)
                     element is ReflectJavaClass && element.isAnnotationType ->
-                        return JvmFunctionSignature.FakeJavaAnnotationConstructor(element.element)
+                        JvmFunctionSignature.FakeJavaAnnotationConstructor(element.element)
                     else -> throw KotlinReflectionInternalError("Incorrect resolution sequence for Java constructor $function ($element)")
                 }
             }