diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createTypeParameter/CreateTypeParameterFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createTypeParameter/CreateTypeParameterFromUsageFix.kt
index 9330b686106..ab9a22e18f4 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createTypeParameter/CreateTypeParameterFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createTypeParameter/CreateTypeParameterFromUsageFix.kt
@@ -43,15 +43,15 @@ import org.jetbrains.kotlin.types.typeUtil.isNullableAny
 import org.jetbrains.kotlin.utils.SmartList
 
 class CreateTypeParameterFromUsageFix(
-        originalElement: KtElement,
-        private val data: CreateTypeParameterData,
-        private val presentTypeParameterNames: Boolean
+    originalElement: KtElement,
+    private val data: CreateTypeParameterData,
+    private val presentTypeParameterNames: Boolean
 ) : CreateFromUsageFixBase<KtElement>(originalElement) {
     override fun getText(): String {
         val prefix = "type parameter".let { if (data.typeParameters.size > 1) StringUtil.pluralize(it) else it }
         val typeParametersText = if (presentTypeParameterNames) data.typeParameters.joinToString(prefix = " ") { "'${it.name}'" } else ""
         val containerText = ElementDescriptionUtil.getElementDescription(data.declaration, UsageViewTypeLocation.INSTANCE) +
-                            " '${data.declaration.name}'"
+                " '${data.declaration.name}'"
         return "Create $prefix$typeParametersText in $containerText"
     }
 
@@ -68,20 +68,20 @@ class CreateTypeParameterFromUsageFix(
             runReadAction {
                 val expectedTypeArgumentCount = declaration.typeParameters.size + data.typeParameters.size
                 ReferencesSearch
-                        .search(declaration)
-                        .mapNotNull {
-                            it.element.getParentOfTypeAndBranch<KtUserType> { referenceExpression } ?:
-                            it.element.getParentOfTypeAndBranch<KtCallElement> { calleeExpression }
+                    .search(declaration)
+                    .mapNotNull {
+                        it.element.getParentOfTypeAndBranch<KtUserType> { referenceExpression }
+                            ?: it.element.getParentOfTypeAndBranch<KtCallElement> { calleeExpression }
+                    }
+                    .filter {
+                        val arguments = when (it) {
+                            is KtUserType -> it.typeArguments
+                            is KtCallElement -> it.typeArguments
+                            else -> return@filter false
                         }
-                        .filter {
-                            val arguments = when (it) {
-                                is KtUserType -> it.typeArguments
-                                is KtCallElement -> it.typeArguments
-                                else -> return@filter false
-                            }
-                            arguments.size != expectedTypeArgumentCount
-                        }
-                        .toSet()
+                        arguments.size != expectedTypeArgumentCount
+                    }
+                    .toSet()
             }
         } ?: return emptyList()
 
@@ -94,8 +94,7 @@ class CreateTypeParameterFromUsageFix(
                 val upperBoundType = typeParameter.upperBoundType
                 val upperBoundText = if (upperBoundType != null && !upperBoundType.isNullableAny()) {
                     IdeDescriptorRenderers.SOURCE_CODE.renderType(upperBoundType)
-                }
-                else null
+                } else null
                 val upperBound = upperBoundText?.let { psiFactory.createType(it) }
                 val newTypeParameterText = if (upperBound != null) "${typeParameter.name} : ${upperBound.text}" else typeParameter.name
                 val newTypeParameter = declaration.addTypeParameter(psiFactory.createTypeParameter(newTypeParameterText))!!
@@ -104,8 +103,8 @@ class CreateTypeParameterFromUsageFix(
                 val anonymizedTypeParameter = createFakeTypeParameterDescriptor(typeParameter.fakeTypeParameter.containingDeclaration, "_")
                 val anonymizedUpperBoundText = upperBoundType?.let {
                     TypeSubstitutor
-                            .create(mapOf(typeParameter.fakeTypeParameter.typeConstructor to TypeProjectionImpl(anonymizedTypeParameter.defaultType)))
-                            .substitute(upperBoundType, Variance.INVARIANT)
+                        .create(mapOf(typeParameter.fakeTypeParameter.typeConstructor to TypeProjectionImpl(anonymizedTypeParameter.defaultType)))
+                        .substitute(upperBoundType, Variance.INVARIANT)
                 }?.let {
                     IdeDescriptorRenderers.SOURCE_CODE.renderType(it)
                 }
@@ -117,20 +116,15 @@ class CreateTypeParameterFromUsageFix(
                     when (it) {
                         is KtUserType -> {
                             val typeArgumentList = it.typeArgumentList
-                            elementsToShorten += if (typeArgumentList != null) {
-                                typeArgumentList.addArgument(anonymizedUpperBoundAsTypeArg)
-                            }
-                            else {
-                                it.addAfter(
-                                        psiFactory.createTypeArguments("<${anonymizedUpperBoundAsTypeArg.text}>"),
-                                        it.referenceExpression!!
-                                ) as KtTypeArgumentList
-                            }
+                            elementsToShorten += typeArgumentList?.addArgument(anonymizedUpperBoundAsTypeArg) ?: it.addAfter(
+                                psiFactory.createTypeArguments("<${anonymizedUpperBoundAsTypeArg.text}>"),
+                                it.referenceExpression!!
+                            ) as KtTypeArgumentList
                         }
                         is KtCallElement -> {
-                            if (it.analyze(BodyResolveMode.PARTIAL_WITH_DIAGNOSTICS).diagnostics.forElement(it.calleeExpression!!).any {
-                                it.factory in Errors.TYPE_INFERENCE_ERRORS
-                            }) {
+                            if (it.analyze(BodyResolveMode.PARTIAL_WITH_DIAGNOSTICS).diagnostics.forElement(it.calleeExpression!!).any { diagnostic ->
+                                    diagnostic.factory in Errors.TYPE_INFERENCE_ERRORS
+                                }) {
                                 callsToExplicateArguments += it
                             }
                         }
@@ -148,8 +142,7 @@ class CreateTypeParameterFromUsageFix(
                         }
 
                         it.typeArgumentList
-                    }
-                    else {
+                    } else {
                         typeArgumentList.addArgument(anonymizedUpperBoundAsTypeArg)
                     }
                 }