Minor. Reformat org.jetbrains.kotlin.idea.codeInsight.postfix

idea/src/org/jetbrains/kotlin/idea/codeInsight/postfix/KtPostfixTemplateProvider.kt

@@ -42,23 +42,23 @@ import org.jetbrains.kotlin.types.typeUtil.isBoolean
 
 class KtPostfixTemplateProvider : PostfixTemplateProvider {
     override fun getTemplates() = setOf(
-            KtNotPostfixTemplate,
+        KtNotPostfixTemplate,
-            KtIfExpressionPostfixTemplate,
+        KtIfExpressionPostfixTemplate,
-            KtElseExpressionPostfixTemplate,
+        KtElseExpressionPostfixTemplate,
-            KtNotNullPostfixTemplate("notnull"),
+        KtNotNullPostfixTemplate("notnull"),
-            KtNotNullPostfixTemplate("nn"),
+        KtNotNullPostfixTemplate("nn"),
-            KtIsNullPostfixTemplate,
+        KtIsNullPostfixTemplate,
-            KtWhenExpressionPostfixTemplate,
+        KtWhenExpressionPostfixTemplate,
-            KtTryPostfixTemplate,
+        KtTryPostfixTemplate,
-            KtIntroduceVariablePostfixTemplate("val"),
+        KtIntroduceVariablePostfixTemplate("val"),
-            KtIntroduceVariablePostfixTemplate("var"),
+        KtIntroduceVariablePostfixTemplate("var"),
-            KtForEachPostfixTemplate("for"),
+        KtForEachPostfixTemplate("for"),
-            KtForEachPostfixTemplate("iter"),
+        KtForEachPostfixTemplate("iter"),
-            KtAssertPostfixTemplate,
+        KtAssertPostfixTemplate,
-            KtParenthesizedPostfixTemplate,
+        KtParenthesizedPostfixTemplate,
-            KtSoutPostfixTemplate,
+        KtSoutPostfixTemplate,
-            KtReturnPostfixTemplate,
+        KtReturnPostfixTemplate,
-            KtWhilePostfixTemplate
+        KtWhilePostfixTemplate
     )
 
     override fun isTerminalSymbol(currentChar: Char) = currentChar == '.' || currentChar == '!'
@@ -82,54 +82,54 @@ class KtPostfixTemplateProvider : PostfixTemplateProvider {
 }
 
 private object KtNotPostfixTemplate : NotPostfixTemplate(
-        KtPostfixTemplatePsiInfo,
+    KtPostfixTemplatePsiInfo,
-        createExpressionSelector { it.isBoolean() }
+    createExpressionSelector { it.isBoolean() }
 )
 
 private class KtIntroduceVariablePostfixTemplate(
-        val kind: String
+    val kind: String
 ) : PostfixTemplateWithExpressionSelector(kind, "$kind name = expression", createExpressionSelector()) {
     override fun expandForChooseExpression(expression: PsiElement, editor: Editor) {
         KotlinIntroduceVariableHandler.doRefactoring(
-                expression.project, editor, expression as KtExpression,
+            expression.project, editor, expression as KtExpression,
-                isVar = kind == "var",
+            isVar = kind == "var",
-                occurrencesToReplace = null,
+            occurrencesToReplace = null,
-                onNonInteractiveFinish = null
+            onNonInteractiveFinish = null
         )
     }
 }
 
 internal object KtPostfixTemplatePsiInfo : PostfixTemplatePsiInfo() {
     override fun createExpression(context: PsiElement, prefix: String, suffix: String) =
-            KtPsiFactory(context.project).createExpression(prefix + context.text + suffix)
+        KtPsiFactory(context.project).createExpression(prefix + context.text + suffix)
 
     override fun getNegatedExpression(element: PsiElement) = (element as KtExpression).negate()
 }
 
 internal fun createExpressionSelector(
-        checkCanBeUsedAsValue: Boolean = true,
+    checkCanBeUsedAsValue: Boolean = true,
-        statementsOnly: Boolean = false,
+    statementsOnly: Boolean = false,
-        typePredicate: ((KotlinType) -> Boolean)? = null
+    typePredicate: ((KotlinType) -> Boolean)? = null
 ): PostfixTemplateExpressionSelector {
     val predicate: ((KtExpression, BindingContext) -> Boolean)? =
-            if (typePredicate != null) { expression, bindingContext ->
+        if (typePredicate != null) { expression, bindingContext ->
-                    expression.getType(bindingContext)?.let(typePredicate) ?: false
+            expression.getType(bindingContext)?.let(typePredicate) ?: false
-            }
+        }
-            else null
+        else null
     return createExpressionSelectorWithComplexFilter(checkCanBeUsedAsValue, statementsOnly, predicate)
 }
 
 internal fun createExpressionSelectorWithComplexFilter(
-        // Do not suggest expressions like 'val a = 1'/'for ...'
+    // Do not suggest expressions like 'val a = 1'/'for ...'
-        checkCanBeUsedAsValue: Boolean = true,
+    checkCanBeUsedAsValue: Boolean = true,
-        statementsOnly: Boolean = false,
+    statementsOnly: Boolean = false,
-        predicate: ((KtExpression, BindingContext) -> Boolean)? = null
+    predicate: ((KtExpression, BindingContext) -> Boolean)? = null
 ): PostfixTemplateExpressionSelector = KtExpressionPostfixTemplateSelector(checkCanBeUsedAsValue, statementsOnly, predicate)
 
 private class KtExpressionPostfixTemplateSelector(
-        private val checkCanBeUsedAsValue: Boolean,
+    private val checkCanBeUsedAsValue: Boolean,
-        private val statementsOnly: Boolean,
+    private val statementsOnly: Boolean,
-        private val predicate: ((KtExpression, BindingContext) -> Boolean)?
+    private val predicate: ((KtExpression, BindingContext) -> Boolean)?
 ) : PostfixTemplateExpressionSelector {
 
     private fun filterElement(element: PsiElement): Boolean {
@@ -156,11 +156,11 @@ private class KtExpressionPostfixTemplateSelector(
     }
 
     private fun KtExpression.canBeUsedAsValue() =
-            !KtPsiUtil.isAssignment(this) &&
+        !KtPsiUtil.isAssignment(this) &&
-            !this.isNamedDeclaration &&
+                !this.isNamedDeclaration &&
-            this !is KtLoopExpression &&
+                this !is KtLoopExpression &&
-            // if's only with else may be treated as expressions
+                // if's only with else may be treated as expressions
-            !isIfWithoutElse
+                !isIfWithoutElse
 
     private val KtExpression.isIfWithoutElse: Boolean
         get() = (this is KtIfExpression && this.elseKeyword == null)
@@ -169,11 +169,11 @@ private class KtExpressionPostfixTemplateSelector(
         val originalFile = context.containingFile.originalFile
         val textRange = context.textRange
         val originalElement = findElementOfClassAtRange(originalFile, textRange.startOffset, textRange.endOffset, context::class.java)
-                              ?: return emptyList()
+            ?: return emptyList()
 
         val expressions = originalElement.parentsWithSelf
-                .filterIsInstance<KtExpression>()
+            .filterIsInstance<KtExpression>()
-                .takeWhile { !it.isBlockBodyInDeclaration }
+            .takeWhile { !it.isBlockBodyInDeclaration }
 
         val boundExpression = expressions.firstOrNull { it.parent.endOffset > offset }
         val boundElementParent = boundExpression?.parent
@@ -181,10 +181,10 @@ private class KtExpressionPostfixTemplateSelector(
         if (boundElementParent is KtDotQualifiedExpression && boundExpression == boundElementParent.receiverExpression) {
             val qualifiedExpressionEnd = boundElementParent.endOffset
             expressions
-                    .dropWhile { it != boundElementParent }
+                .dropWhile { it != boundElementParent }
-                    .drop(1)
+                .drop(1)
-                    .takeWhile { it.endOffset == qualifiedExpressionEnd }
+                .takeWhile { it.endOffset == qualifiedExpressionEnd }
-                    .toCollection(filteredByOffset)
+                .toCollection(filteredByOffset)
         }
 
         val result = filteredByOffset.filter(this::filterElement)

idea/src/org/jetbrains/kotlin/idea/codeInsight/postfix/stringBasedPostfixTemplates.kt

@@ -34,23 +34,23 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.isBoolean
 
 internal abstract class ConstantStringBasedPostfixTemplate(
-        name: String,
+    name: String,
-        desc: String,
+    desc: String,
-        private val template: String,
+    private val template: String,
-        selector: PostfixTemplateExpressionSelector
+    selector: PostfixTemplateExpressionSelector
-) :  StringBasedPostfixTemplate(name, desc, selector) {
+) : StringBasedPostfixTemplate(name, desc, selector) {
     override fun getTemplateString(element: PsiElement) = template
 
     override fun getElementToRemove(expr: PsiElement?) = expr
 }
 
 internal class KtForEachPostfixTemplate(
-        name: String
+    name: String
 ) : ConstantStringBasedPostfixTemplate(
-        name,
+    name,
-        "for (item in expr)",
+    "for (item in expr)",
-        "for (\$name$ in \$expr$) {\n    \$END$\n}",
+    "for (\$name$ in \$expr$) {\n    \$END$\n}",
-        createExpressionSelectorWithComplexFilter(statementsOnly = true, predicate = KtExpression::hasIterableType)
+    createExpressionSelectorWithComplexFilter(statementsOnly = true, predicate = KtExpression::hasIterableType)
 ) {
     override fun setVariables(template: Template, element: PsiElement) {
         val name = MacroCallNode(SuggestVariableNameMacro())
@@ -67,35 +67,35 @@ private fun KtExpression.hasIterableType(bindingContext: BindingContext): Boolea
 }
 
 internal object KtAssertPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "assert",
+    "assert",
-        "assert(expr) { \"\" }",
+    "assert(expr) { \"\" }",
-        "assert(\$expr$) { \"\$END$\" }",
+    "assert(\$expr$) { \"\$END$\" }",
-        createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
+    createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
 )
 
 internal object KtParenthesizedPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "par", "(expr)",
+    "par", "(expr)",
-        "(\$expr$)\$END$",
+    "(\$expr$)\$END$",
-        createExpressionSelector()
+    createExpressionSelector()
 )
 
 internal object KtSoutPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "sout",
+    "sout",
-        "println(expr)",
+    "println(expr)",
-        "println(\$expr$)\$END$",
+    "println(\$expr$)\$END$",
-        createExpressionSelector(statementsOnly = true)
+    createExpressionSelector(statementsOnly = true)
 )
 
 internal object KtReturnPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "return",
+    "return",
-        "return expr",
+    "return expr",
-        "return \$expr$\$END$",
+    "return \$expr$\$END$",
-        createExpressionSelector(statementsOnly = true)
+    createExpressionSelector(statementsOnly = true)
 )
 
 internal object KtWhilePostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "while",
+    "while",
-        "while (expr) {}",
+    "while (expr) {}",
-        "while (\$expr$) {\n\$END$\n}",
+    "while (\$expr$) {\n\$END$\n}",
-        createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
+    createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
 )

idea/src/org/jetbrains/kotlin/idea/codeInsight/postfix/surrounderBasedPostfixTemplates.kt

@@ -28,51 +28,51 @@ import org.jetbrains.kotlin.types.typeUtil.isBoolean
 
 
 internal object KtIfExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "if", "if (expr)",
+    "if", "if (expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
+    KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
 ) {
     override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
 }
 
 internal object KtElseExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "else", "if (!expr)",
+    "else", "if (!expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
+    KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
 ) {
     override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
     override fun getWrappedExpression(expression: PsiElement?) = (expression as KtExpression).negate()
 }
 
 internal class KtNotNullPostfixTemplate(val name: String) : SurroundPostfixTemplateBase(
-        name, "if (expr != null)",
+    name, "if (expr != null)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
+    KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
 ) {
     override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
     override fun getTail() = "!= null"
 }
 
 internal object KtIsNullPostfixTemplate : SurroundPostfixTemplateBase(
-        "null", "if (expr == null)",
+    "null", "if (expr == null)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
+    KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
 ) {
     override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
     override fun getTail() = "== null"
 }
 
 internal object KtWhenExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "when", "when (expr)",
+    "when", "when (expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector()
+    KtPostfixTemplatePsiInfo, createExpressionSelector()
 ) {
     override fun getSurrounder() = KotlinWhenSurrounder()
 }
 
 internal object KtTryPostfixTemplate : SurroundPostfixTemplateBase(
-        "try", "try { code } catch (e: Exception) { }",
+    "try", "try { code } catch (e: Exception) { }",
-        KtPostfixTemplatePsiInfo,
+    KtPostfixTemplatePsiInfo,
-        createExpressionSelector(
+    createExpressionSelector(
-                checkCanBeUsedAsValue = false,
+        checkCanBeUsedAsValue = false,
-                // Do not suggest 'val x = try { init } catch (e: Exception) { }'
+        // Do not suggest 'val x = try { init } catch (e: Exception) { }'
-                statementsOnly = true
+        statementsOnly = true
-        )
+    )
 ) {
     override fun getSurrounder() = KotlinTryCatchSurrounder()
 }