Cleanup: post-cleanup after deprecation cleanup in compiler

Replace `takeIf { !expr }` with `takeUnless { expr }`.
Cleanup redundant parethesis as in `listOf((expr))`.
Replace `listOf(expr)` with `expr.let(::listOf)` where the former caused significant indentation change.

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

@@ -63,8 +63,7 @@ object BuiltinSpecialBridgesUtil {
 
         val specialBridgeExists = function.getSpecialBridgeSignatureIfExists(signatureByDescriptor) != null
         val specialBridgesSignaturesInSuperClass = function.overriddenTreeAsSequence(useOriginal = true).mapNotNull {
-            if (it === function) return@mapNotNull null
-            it.getSpecialBridgeSignatureIfExists(signatureByDescriptor)
+            it.takeUnless { it === function }?.getSpecialBridgeSignatureIfExists(signatureByDescriptor)
         }
         val isTherePossibleClashWithSpecialBridge =
                 specialBridgeSignature in specialBridgesSignaturesInSuperClass

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt

@@ -288,7 +288,7 @@ class CoroutineCodegen private constructor(
     }
 
     private fun allFunctionParameters() =
-            listOfNotNull(originalSuspendFunctionDescriptor.extensionReceiverParameter) +
+            originalSuspendFunctionDescriptor.extensionReceiverParameter.let(::listOfNotNull) +
             originalSuspendFunctionDescriptor.valueParameters.orEmpty()
 
     private fun ParameterDescriptor.getFieldInfoForCoroutineLambdaParameter() =

compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt

@@ -61,7 +61,7 @@ object KotlinCompilerClient {
     ): CompileService? {
         val flagFile = System.getProperty(COMPILE_DAEMON_CLIENT_ALIVE_PATH_PROPERTY)
                                ?.let(String::trimQuotes)
-                               ?.takeIf { !it.isBlank() }
+                               ?.takeUnless(String::isBlank)
                                ?.let(::File)
                                ?.takeIf(File::exists)
                                ?: makeAutodeletingFlagFile(baseDir = File(daemonOptions.runFilesPathOrDefault))

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.kt

@@ -42,8 +42,8 @@ internal fun nonProjectionParametrization(samType: SimpleType): SimpleType? {
                     projection.projectionKind == Variance.INVARIANT -> projection
 
                     projection.isStarProjection ->
-                        parameter.upperBounds.first().takeIf {
-                            t -> !t.contains { it.constructor.declarationDescriptor in parametersSet }
+                        parameter.upperBounds.first().takeUnless {
+                            t -> t.contains { it.constructor.declarationDescriptor in parametersSet }
                         }?.asTypeProjection() ?: return@nonProjectionParametrization null
 
                     else -> projection.type.asTypeProjection()

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt

@@ -417,12 +417,12 @@ class QualifiedExpressionResolver {
         val qualifierDescriptor = when (receiver) {
             is PackageQualifier -> {
                 val childPackageFQN = receiver.descriptor.fqName.child(name)
-                receiver.descriptor.module.getPackage(childPackageFQN).takeIf { !it.isEmpty() } ?:
+                receiver.descriptor.module.getPackage(childPackageFQN).takeUnless { it.isEmpty() } ?:
                 receiver.descriptor.memberScope.getContributedClassifier(name, location)
             }
             is ClassQualifier -> receiver.staticScope.getContributedClassifier(name, location)
             null -> context.scope.findClassifier(name, location) ?:
-                    context.scope.ownerDescriptor.module.getPackage(FqName.ROOT.child(name)).takeIf { !it.isEmpty() }
+                    context.scope.ownerDescriptor.module.getPackage(FqName.ROOT.child(name)).takeUnless { it.isEmpty() }
             is ReceiverValue -> receiver.type.memberScope.memberScopeAsImportingScope().findClassifier(name, location)
             else -> null
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DefaultImportProvider.kt

@@ -55,7 +55,7 @@ class DefaultImportProvider(
                 defaultImports
                         .filter { it.isAllUnder }
                         .mapNotNull {
-                            it.fqName.takeIf { !it.isSubpackageOf(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) }
+                            it.fqName.takeUnless { it.isSubpackageOf(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) }
                         }
         val nonKotlinAliasedTypeFqNames =
                 builtinTypeAliases

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt

@@ -167,8 +167,8 @@ class EnumClassLowering(val context: JvmBackendContext) : ClassLoweringPass {
         private fun lowerEnumEntries() {
             irClass.declarations.transformFlat { declaration ->
                 if (declaration is IrEnumEntry) {
-                    listOf(createFieldForEnumEntry(declaration)) +
-                    listOfNotNull(lowerEnumEntryClass(declaration.correspondingClass))
+                    listOfNotNull(createFieldForEnumEntry(declaration),
+                                  lowerEnumEntryClass(declaration.correspondingClass))
                 }
                 else null
             }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt

@@ -50,12 +50,10 @@ fun KtElement.toLightElements(): List<PsiNamedElement> =
             is KtSecondaryConstructor -> LightClassUtil.getLightClassMethods(this as KtFunction)
             is KtProperty -> LightClassUtil.getLightClassPropertyMethods(this).allDeclarations
             is KtPropertyAccessor -> listOfNotNull(LightClassUtil.getLightClassAccessorMethod(this))
-            is KtParameter -> ArrayList<PsiNamedElement>().let { elements ->
+            is KtParameter -> mutableListOf<PsiNamedElement>().also { elements ->
                 toPsiParameters().toCollection(elements)
                 LightClassUtil.getLightClassPropertyMethods(this).toCollection(elements)
-                toAnnotationLightMethod()?.let { elements.add(it) }
-
-                elements
+                toAnnotationLightMethod()?.let(elements::add)
             }
             is KtTypeParameter -> toPsiTypeParameters()
             is KtFile -> listOfNotNull(findFacadeClass())

compiler/tests/org/jetbrains/kotlin/scripts/ScriptTemplateTest.kt

@@ -334,12 +334,10 @@ class TestKotlinScriptDependenciesResolver : TestKotlinScriptDummyDependenciesRe
             when (it) {
                 is DependsOn -> if (it.path == "@{runtime}") listOf(kotlinPaths.runtimePath, kotlinPaths.scriptRuntimePath) else listOf(File(it.path))
                 is DependsOnTwo -> listOf(it.path1, it.path2).flatMap {
-                    it.let {
-                        when {
-                            it.isBlank() -> emptyList()
-                            it == "@{runtime}" -> listOf(kotlinPaths.runtimePath, kotlinPaths.scriptRuntimePath)
-                            else -> listOf(File(it))
-                        }
+                    when {
+                        it.isBlank() -> emptyList()
+                        it == "@{runtime}" -> listOf(kotlinPaths.runtimePath, kotlinPaths.scriptRuntimePath)
+                        else -> listOf(File(it))
                     }
                 }
                 is InvalidScriptResolverAnnotation -> throw Exception("Invalid annotation ${it.name}", it.error)

compiler/util/src/org/jetbrains/kotlin/utils/reflectionUtil.kt

@@ -183,7 +183,7 @@ private class StringArgsConverter : ArgsConverter<String> {
                     DoubleArray::class -> args.map { it?.toDoubleOrNull() }
                     BooleanArray::class -> args.map { it?.toBoolean() }
                     else -> null
-                }?.toList()?.takeIf { list -> list.none { it == null } }?.toTypedArray()
+                }?.toList()?.takeUnless { null in it }?.toTypedArray()
 
         val parameterType = parameter.type
         if (parameterType.jvmErasure.java.isArray) {