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

2018-07-04 11:47:20 +03:00
parent 6f4aa2296d
commit 4ab97e8454
3 changed files with 97 additions and 97 deletions
@@ -42,23 +42,23 @@ import org.jetbrains.kotlin.types.typeUtil.isBoolean

 class KtPostfixTemplateProvider : PostfixTemplateProvider {
    override fun getTemplates() = setOf(
-            KtNotPostfixTemplate,
-            KtIfExpressionPostfixTemplate,
-            KtElseExpressionPostfixTemplate,
-            KtNotNullPostfixTemplate("notnull"),
-            KtNotNullPostfixTemplate("nn"),
-            KtIsNullPostfixTemplate,
-            KtWhenExpressionPostfixTemplate,
-            KtTryPostfixTemplate,
-            KtIntroduceVariablePostfixTemplate("val"),
-            KtIntroduceVariablePostfixTemplate("var"),
-            KtForEachPostfixTemplate("for"),
-            KtForEachPostfixTemplate("iter"),
-            KtAssertPostfixTemplate,
-            KtParenthesizedPostfixTemplate,
-            KtSoutPostfixTemplate,
-            KtReturnPostfixTemplate,
-            KtWhilePostfixTemplate
+        KtNotPostfixTemplate,
+        KtIfExpressionPostfixTemplate,
+        KtElseExpressionPostfixTemplate,
+        KtNotNullPostfixTemplate("notnull"),
+        KtNotNullPostfixTemplate("nn"),
+        KtIsNullPostfixTemplate,
+        KtWhenExpressionPostfixTemplate,
+        KtTryPostfixTemplate,
+        KtIntroduceVariablePostfixTemplate("val"),
+        KtIntroduceVariablePostfixTemplate("var"),
+        KtForEachPostfixTemplate("for"),
+        KtForEachPostfixTemplate("iter"),
+        KtAssertPostfixTemplate,
+        KtParenthesizedPostfixTemplate,
+        KtSoutPostfixTemplate,
+        KtReturnPostfixTemplate,
+        KtWhilePostfixTemplate
    )

    override fun isTerminalSymbol(currentChar: Char) = currentChar == '.' || currentChar == '!'
@@ -82,54 +82,54 @@ class KtPostfixTemplateProvider : PostfixTemplateProvider {
 }

 private object KtNotPostfixTemplate : NotPostfixTemplate(
-        KtPostfixTemplatePsiInfo,
-        createExpressionSelector { it.isBoolean() }
+    KtPostfixTemplatePsiInfo,
+    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,
-                isVar = kind == "var",
-                occurrencesToReplace = null,
-                onNonInteractiveFinish = null
+            expression.project, editor, expression as KtExpression,
+            isVar = kind == "var",
+            occurrencesToReplace = 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,
-        statementsOnly: Boolean = false,
-        typePredicate: ((KotlinType) -> Boolean)? = null
+    checkCanBeUsedAsValue: Boolean = true,
+    statementsOnly: Boolean = false,
+    typePredicate: ((KotlinType) -> Boolean)? = null
 ): PostfixTemplateExpressionSelector {
    val predicate: ((KtExpression, BindingContext) -> Boolean)? =
-            if (typePredicate != null) { expression, bindingContext ->
-                    expression.getType(bindingContext)?.let(typePredicate) ?: false
-            }
-            else null
+        if (typePredicate != null) { expression, bindingContext ->
+            expression.getType(bindingContext)?.let(typePredicate) ?: false
+        }
+        else null
    return createExpressionSelectorWithComplexFilter(checkCanBeUsedAsValue, statementsOnly, predicate)
 }

 internal fun createExpressionSelectorWithComplexFilter(
-        // Do not suggest expressions like 'val a = 1'/'for ...'
-        checkCanBeUsedAsValue: Boolean = true,
-        statementsOnly: Boolean = false,
-        predicate: ((KtExpression, BindingContext) -> Boolean)? = null
+    // Do not suggest expressions like 'val a = 1'/'for ...'
+    checkCanBeUsedAsValue: Boolean = true,
+    statementsOnly: Boolean = false,
+    predicate: ((KtExpression, BindingContext) -> Boolean)? = null
 ): PostfixTemplateExpressionSelector = KtExpressionPostfixTemplateSelector(checkCanBeUsedAsValue, statementsOnly, predicate)

 private class KtExpressionPostfixTemplateSelector(
-        private val checkCanBeUsedAsValue: Boolean,
-        private val statementsOnly: Boolean,
-        private val predicate: ((KtExpression, BindingContext) -> Boolean)?
+    private val checkCanBeUsedAsValue: Boolean,
+    private val statementsOnly: 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) &&
-            !this.isNamedDeclaration &&
-            this !is KtLoopExpression &&
-            // if's only with else may be treated as expressions
-            !isIfWithoutElse
+        !KtPsiUtil.isAssignment(this) &&
+                !this.isNamedDeclaration &&
+                this !is KtLoopExpression &&
+                // if's only with else may be treated as expressions
+                !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>()
-                .takeWhile { !it.isBlockBodyInDeclaration }
+            .filterIsInstance<KtExpression>()
+            .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 }
-                    .drop(1)
-                    .takeWhile { it.endOffset == qualifiedExpressionEnd }
-                    .toCollection(filteredByOffset)
+                .dropWhile { it != boundElementParent }
+                .drop(1)
+                .takeWhile { it.endOffset == qualifiedExpressionEnd }
+                .toCollection(filteredByOffset)
        }

        val result = filteredByOffset.filter(this::filterElement)
@@ -34,23 +34,23 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.isBoolean

 internal abstract class ConstantStringBasedPostfixTemplate(
-        name: String,
-        desc: String,
-        private val template: String,
-        selector: PostfixTemplateExpressionSelector
-) :  StringBasedPostfixTemplate(name, desc, selector) {
+    name: String,
+    desc: String,
+    private val template: String,
+    selector: PostfixTemplateExpressionSelector
+) : 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,
-        "for (item in expr)",
-        "for (\$name$ in \$expr$) {\n    \$END$\n}",
-        createExpressionSelectorWithComplexFilter(statementsOnly = true, predicate = KtExpression::hasIterableType)
+    name,
+    "for (item in expr)",
+    "for (\$name$ in \$expr$) {\n    \$END$\n}",
+    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(expr) { \"\" }",
-        "assert(\$expr$) { \"\$END$\" }",
-        createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
+    "assert",
+    "assert(expr) { \"\" }",
+    "assert(\$expr$) { \"\$END$\" }",
+    createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
 )

 internal object KtParenthesizedPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "par", "(expr)",
-        "(\$expr$)\$END$",
-        createExpressionSelector()
+    "par", "(expr)",
+    "(\$expr$)\$END$",
+    createExpressionSelector()
 )

 internal object KtSoutPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "sout",
-        "println(expr)",
-        "println(\$expr$)\$END$",
-        createExpressionSelector(statementsOnly = true)
+    "sout",
+    "println(expr)",
+    "println(\$expr$)\$END$",
+    createExpressionSelector(statementsOnly = true)
 )

 internal object KtReturnPostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "return",
-        "return expr",
-        "return \$expr$\$END$",
-        createExpressionSelector(statementsOnly = true)
+    "return",
+    "return expr",
+    "return \$expr$\$END$",
+    createExpressionSelector(statementsOnly = true)
 )

 internal object KtWhilePostfixTemplate : ConstantStringBasedPostfixTemplate(
-        "while",
-        "while (expr) {}",
-        "while (\$expr$) {\n\$END$\n}",
-        createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
+    "while",
+    "while (expr) {}",
+    "while (\$expr$) {\n\$END$\n}",
+    createExpressionSelector(statementsOnly = true, typePredicate = KotlinType::isBoolean)
 )
@@ -28,51 +28,51 @@ import org.jetbrains.kotlin.types.typeUtil.isBoolean


 internal object KtIfExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "if", "if (expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
+    "if", "if (expr)",
+    KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
 ) {
    override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
 }

 internal object KtElseExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "else", "if (!expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector { it.isBoolean() }
+    "else", "if (!expr)",
+    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)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
+    name, "if (expr != null)",
+    KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
 ) {
    override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
    override fun getTail() = "!= null"
 }

 internal object KtIsNullPostfixTemplate : SurroundPostfixTemplateBase(
-        "null", "if (expr == null)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
+    "null", "if (expr == null)",
+    KtPostfixTemplatePsiInfo, createExpressionSelector(typePredicate = TypeUtils::isNullableType)
 ) {
    override fun getSurrounder() = KotlinWithIfExpressionSurrounder(withElse = false)
    override fun getTail() = "== null"
 }

 internal object KtWhenExpressionPostfixTemplate : SurroundPostfixTemplateBase(
-        "when", "when (expr)",
-        KtPostfixTemplatePsiInfo, createExpressionSelector()
+    "when", "when (expr)",
+    KtPostfixTemplatePsiInfo, createExpressionSelector()
 ) {
    override fun getSurrounder() = KotlinWhenSurrounder()
 }

 internal object KtTryPostfixTemplate : SurroundPostfixTemplateBase(
-        "try", "try { code } catch (e: Exception) { }",
-        KtPostfixTemplatePsiInfo,
-        createExpressionSelector(
-                checkCanBeUsedAsValue = false,
-                // Do not suggest 'val x = try { init } catch (e: Exception) { }'
-                statementsOnly = true
-        )
+    "try", "try { code } catch (e: Exception) { }",
+    KtPostfixTemplatePsiInfo,
+    createExpressionSelector(
+        checkCanBeUsedAsValue = false,
+        // Do not suggest 'val x = try { init } catch (e: Exception) { }'
+        statementsOnly = true
+    )
 ) {
    override fun getSurrounder() = KotlinTryCatchSurrounder()
 }