Bugfix. Spaces are not inserted after { and before } in lambda expres…

…sions (#711) (#712)

* Bugfix. Spaces are not inserted after { and before } in lambda expressions

### What's done:
  * Fixed bugs
  * Added more tests

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/AsyncAndSyncRule.kt

@@ -35,7 +35,7 @@ class AsyncAndSyncRule(private val configRules: List<RulesConfig>) : Rule("sync-
     }
 
     private fun checkRunBlocking(node: ASTNode) {
-        node.parent({it.isAsync() || it.isSuspend()})?.let {
+        node.parent({ it.isAsync() || it.isSuspend() })?.let {
             RUN_BLOCKING_INSIDE_ASYNC.warn(configRules, emitWarn, isFixMode, node.text, node.startOffset, node)
         }
     }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/CheckInverseMethodRule.kt

@@ -43,7 +43,7 @@ class CheckInverseMethodRule(private val configRules: List<RulesConfig>) : Rule(
             .treeParent
             .siblings(forward = false)
             .takeWhile { it.elementType in intermediateTokens }
-            .firstOrNull { it.elementType == OPERATION_REFERENCE}
+            .firstOrNull { it.elementType == OPERATION_REFERENCE }
         if (operationRef?.text == "!") {
             INVERSE_FUNCTION_PREFERRED.warnAndFix(configRules, emitWarn, isFixMode, "${methodMap[node.text]} instead of !${node.text}", node.startOffset, node) {
                 val callExpression = CompositeElement(CALL_EXPRESSION)

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/ClassLikeStructuresOrderRule.kt

@@ -95,7 +95,7 @@ class ClassLikeStructuresOrderRule(private val configRules: List<RulesConfig>) :
             unusedClasses)
             .allBlockFlattened()
             .map { astNode ->
-                Pair(astNode, astNode.siblings(false).takeWhile { it.elementType == WHITE_SPACE || it.isPartOfComment()}.toList())
+                Pair(astNode, astNode.siblings(false).takeWhile { it.elementType == WHITE_SPACE || it.isPartOfComment() }.toList())
             }
 
         val classChildren = node.children().filter { it.elementType in childrenTypes }.toList()

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/IdentifierNaming.kt

@@ -185,10 +185,10 @@ class IdentifierNaming(private val configRules: List<RulesConfig>) : Rule("ident
                         // FixMe: cover fixes with tests
                         val correctVariableName = variableName.text.toLowerCamelCase()
                         variableName
-                            .parent({it.elementType == FILE})
+                            .parent({ it.elementType == FILE })
                             ?.findAllVariablesWithUsages { it.name == variableName.text }
                             ?.flatMap { it.value.toList() }
-                            ?.forEach { (it.node.firstChildNode as LeafPsiElement).replaceWithText(correctVariableName)}
+                            ?.forEach { (it.node.firstChildNode as LeafPsiElement).replaceWithText(correctVariableName) }
                         (variableName as LeafPsiElement).replaceWithText(correctVariableName)
                     }
                 }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/LambdaLengthRule.kt

@@ -45,7 +45,7 @@ class LambdaLengthRule(private val configRules: List<RulesConfig>) : Rule("lambd
                     node.treeParent.removeChild(node)
                 }
             }
-            val isIt = copyNode.findAllNodesWithSpecificType(ElementType.REFERENCE_EXPRESSION).map {re -> re.text}.contains("it")
+            val isIt = copyNode.findAllNodesWithSpecificType(ElementType.REFERENCE_EXPRESSION).map { re -> re.text }.contains("it")
             val parameters = node.findChildByType(ElementType.FUNCTION_LITERAL)?.findChildByType(ElementType.VALUE_PARAMETER_LIST)
             if (parameters == null && isIt) {
                 Warnings.TOO_MANY_LINES_IN_LAMBDA.warn(configRules, emitWarn, isFixMode,

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/LambdaParameterOrder.kt

@@ -35,7 +35,7 @@ class LambdaParameterOrder(private val configRules: List<RulesConfig>) : Rule("l
     private fun checkArguments(node: ASTNode) {
         val funArguments = (node.psi as KtFunction).valueParameters
         val sortArguments = funArguments.sortedBy { it.typeReference?.node?.hasChildOfType(FUNCTION_TYPE) }
-        funArguments.filterIndexed {index, ktParameter -> ktParameter != sortArguments[index] }.ifNotEmpty {
+        funArguments.filterIndexed { index, ktParameter -> ktParameter != sortArguments[index] }.ifNotEmpty {
             LAMBDA_IS_NOT_LAST_PARAMETER.warn(configRules, emitWarn, isFixMode, node.findChildByType(IDENTIFIER)!!.text,
                 first().node.startOffset, node)
         }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/OverloadingArgumentsFunction.kt

@@ -43,7 +43,7 @@ class OverloadingArgumentsFunction(private val configRules: List<RulesConfig>) :
             .map { it.psi as KtFunction }
             .filter { it.nameIdentifier!!.text == funPsi.nameIdentifier!!.text && it.valueParameters.containsAll(funPsi.valueParameters) }
             .filter { funPsi.node.findChildBefore(IDENTIFIER, TYPE_REFERENCE)?.text == it.node.findChildBefore(IDENTIFIER, TYPE_REFERENCE)?.text }
-            .filter {funPsi.node.findChildAfter(IDENTIFIER, TYPE_REFERENCE)?.text == it.node.findChildAfter(IDENTIFIER, TYPE_REFERENCE)?.text }
+            .filter { funPsi.node.findChildAfter(IDENTIFIER, TYPE_REFERENCE)?.text == it.node.findChildAfter(IDENTIFIER, TYPE_REFERENCE)?.text }
             .toList()
         if (allOverloadFunction.isNotEmpty()) {
             WRONG_OVERLOADING_FUNCTION_ARGUMENTS.warn(configRules, emitWarn, isFixMode, funPsi.node.findChildByType(IDENTIFIER)!!.text, funPsi.startOffset, funPsi.node)

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/TypeAliasRule.kt

@@ -36,7 +36,7 @@ class TypeAliasRule(private val configRules: List<RulesConfig>) : Rule("type-ali
         if (node.elementType == TYPE_REFERENCE && node
             .parents()
             .map { it.elementType }
-            .none { it == SUPER_TYPE_LIST || it == TYPEALIAS}) {
+            .none { it == SUPER_TYPE_LIST || it == TYPEALIAS }) {
             checkTypeReference(node, TypeAliasConfiguration(configRules.getRuleConfig(TYPE_ALIAS)?.configuration ?: emptyMap()))
         }
     }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/UselessSupertype.kt

@@ -139,7 +139,7 @@ class UselessSupertype(private val configRules: List<RulesConfig>) : Rule("usele
                             it.getIdentifierName()!!.text in methodsName
                 }
             overrideFunctions.forEach {
-                functionNameMap.compute(it.getIdentifierName()!!.text) { _, oldValue -> (oldValue ?: 0) + 1}
+                functionNameMap.compute(it.getIdentifierName()!!.text) { _, oldValue -> (oldValue ?: 0) + 1 }
             }
         }
         return functionNameMap.toMap()

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/files/NewlinesRule.kt

@@ -521,7 +521,7 @@ class NewlinesRule(private val configRules: List<RulesConfig>) : Rule("newlines"
     /**
      * This method checks that complex expression should be replace with new variable
      */
-    private fun ASTNode.isInParentheses() = parent({it.elementType == DOT_QUALIFIED_EXPRESSION || it.elementType == SAFE_ACCESS_EXPRESSION})
+    private fun ASTNode.isInParentheses() = parent({ it.elementType == DOT_QUALIFIED_EXPRESSION || it.elementType == SAFE_ACCESS_EXPRESSION })
         ?.treeParent
         ?.elementType
         ?.let { it in parenthesesTypes }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/files/WhiteSpaceRule.kt

@@ -46,6 +46,7 @@ import com.pinterest.ktlint.core.ast.ElementType.PRIMARY_CONSTRUCTOR
 import com.pinterest.ktlint.core.ast.ElementType.PROPERTY
 import com.pinterest.ktlint.core.ast.ElementType.QUEST
 import com.pinterest.ktlint.core.ast.ElementType.RANGE
+import com.pinterest.ktlint.core.ast.ElementType.RBRACE
 import com.pinterest.ktlint.core.ast.ElementType.RBRACKET
 import com.pinterest.ktlint.core.ast.ElementType.RPAR
 import com.pinterest.ktlint.core.ast.ElementType.SAFE_ACCESS
@@ -63,6 +64,8 @@ import com.pinterest.ktlint.core.ast.ElementType.WHEN_KEYWORD
 import com.pinterest.ktlint.core.ast.ElementType.WHILE_KEYWORD
 import com.pinterest.ktlint.core.ast.ElementType.WHITE_SPACE
 import com.pinterest.ktlint.core.ast.isPartOfComment
+import com.pinterest.ktlint.core.ast.isWhiteSpace
+import com.pinterest.ktlint.core.ast.isWhiteSpaceWithoutNewline
 import com.pinterest.ktlint.core.ast.nextCodeLeaf
 import com.pinterest.ktlint.core.ast.parent
 import com.pinterest.ktlint.core.ast.prevSibling
@@ -116,6 +119,7 @@ class WhiteSpaceRule(private val configRules: List<RulesConfig>) : Rule("horizon
             }
             // braces and other symbols
             LBRACE -> handleLbrace(node)
+            RBRACE -> handleRbrace(node)
             LBRACKET -> handleLbracket(node)
             LPAR -> handleLpar(node)
             RPAR, RBRACKET -> handleToken(node, 0, null)
@@ -160,10 +164,21 @@ class WhiteSpaceRule(private val configRules: List<RulesConfig>) : Rule("horizon
         }
     }
 
+    private fun handleRbrace(node: ASTNode) {
+        if (node.treeParent.elementType == FUNCTION_LITERAL &&
+                !node.treePrev.isWhiteSpace() &&
+                node.treePrev.elementType == BLOCK &&
+                node.treePrev.text.isNotEmpty()) {
+            WRONG_WHITESPACE.warnAndFix(configRules, emitWarn, isFixMode, "there should be a whitespace before }", node.startOffset, node) {
+                node.treeParent.addChild(PsiWhiteSpaceImpl(" "), node)
+            }
+        }
+    }
+
     /**
      * This method covers all other opening braces, not covered in [handleKeywordWithParOrBrace].
      */
-    @Suppress("UnsafeCallOnNullableType", "ComplexMethod")
+    @Suppress("UnsafeCallOnNullableType")
     private fun handleLbrace(node: ASTNode) {
         // `{` can't be the very first symbol in the file, so `!!` should be safe
         val whitespaceOrPrevNode = node.selfOrParentsTreePrev()!!
@@ -183,6 +198,15 @@ class WhiteSpaceRule(private val configRules: List<RulesConfig>) : Rule("horizon
 
         val prevNode = whitespaceOrPrevNode.let { if (it.elementType == WHITE_SPACE) it.treePrev else it }
         val numWhiteSpace = whitespaceOrPrevNode.numWhiteSpaces()
+        handleWhiteSpaceBeforeLeftBrace(node, isFromLambdaAsArgument, numWhiteSpace, whitespaceOrPrevNode, prevNode)
+        handleWhiteSpaceAfterLeftBrace(node)
+    }
+
+    private fun handleWhiteSpaceBeforeLeftBrace(node: ASTNode,
+                                                isFromLambdaAsArgument: Boolean,
+                                                numWhiteSpace: Int?,
+                                                whitespaceOrPrevNode: ASTNode,
+                                                prevNode: ASTNode) {
         // note: the conditions in the following `if`s cannot be collapsed into simple conjunctions
         if (isFromLambdaAsArgument) {
             val isFirstArgument = node
@@ -196,11 +220,18 @@ class WhiteSpaceRule(private val configRules: List<RulesConfig>) : Rule("horizon
                     whitespaceOrPrevNode.treeParent.removeChild(whitespaceOrPrevNode)
                 }
             }
-        } else if (prevNode.elementType !in keywordsWithSpaceAfter) {
-            if (numWhiteSpace != 1) {
-                WRONG_WHITESPACE.warnAndFix(configRules, emitWarn, isFixMode, "there should be a whitespace before '{'", node.startOffset, node) {
-                    prevNode.leaveSingleWhiteSpace()
-                }
+        } else if (prevNode.elementType !in keywordsWithSpaceAfter && numWhiteSpace != 1) {
+            WRONG_WHITESPACE.warnAndFix(configRules, emitWarn, isFixMode, "there should be a whitespace before '{'", node.startOffset, node) {
+                prevNode.leaveSingleWhiteSpace()
+            }
+        }
+    }
+
+    private fun handleWhiteSpaceAfterLeftBrace(node: ASTNode) {
+        if (node.treeParent.elementType == FUNCTION_LITERAL && !node.treeNext.isWhiteSpace() &&
+                node.treeNext.elementType == BLOCK && node.treeNext.text.isNotEmpty()) {
+            WRONG_WHITESPACE.warnAndFix(configRules, emitWarn, isFixMode, "there should be a whitespace after {", node.startOffset, node) {
+                node.treeParent.addChild(PsiWhiteSpaceImpl(" "), node.treeNext)
             }
         }
     }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/kdoc/CommentsFormatting.kt

@@ -200,7 +200,7 @@ class CommentsFormatting(private val configRules: List<RulesConfig>) : Rule("kdo
         }
         if (node.treeParent.elementType == FILE) {
             // This case is for top-level comments that are located in the beginning of the line and therefore don't need any spaces before.
-            if (!node.treePrev.isWhiteSpaceWithNewline() && node.treePrev.text.count { it == ' '} > 0) {
+            if (!node.treePrev.isWhiteSpaceWithNewline() && node.treePrev.text.count { it == ' ' } > 0) {
                 COMMENT_WHITE_SPACE.warnAndFix(configRules, emitWarn, isFixMode,
                     "There should be 0 space(s) before comment text, but are ${node.treePrev.text.count { it == ' ' }} in ${node.text}",
                     node.startOffset, node) {

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/kdoc/KdocComments.kt

@@ -83,7 +83,7 @@ class KdocComments(private val configRules: List<RulesConfig>) : Rule("kdoc-comm
             ?.findChildByType(KDOC) ?: return
         val propertiesInKdoc = kdocBeforeClass
             .kDocTags()
-            ?.filter { it.knownTag == KDocKnownTag.PROPERTY}
+            ?.filter { it.knownTag == KDocKnownTag.PROPERTY }
         val propertyNames = (node.psi as KtParameterList)
             .parameters
             .mapNotNull { it.nameIdentifier?.text }

diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/utils/KotlinParser.kt

@@ -50,7 +50,7 @@ class KotlinParser {
             }
         }  // I don't really understand what's going on here, but thanks to this, you can use this node in the future
         val project = KotlinCoreEnvironment.createForProduction(
-            Disposable {},
+            Disposable { },
             compilerConfiguration,
             EnvironmentConfigFiles.JVM_CONFIG_FILES
         ).project  // create project

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/spaces/WhiteSpaceRuleFixTest.kt

@@ -52,7 +52,13 @@ class WhiteSpaceRuleFixTest : FixTestBase("test/paragraph3/spaces", ::WhiteSpace
 
     @Test
     @Tag(WarningNames.WRONG_WHITESPACE)
-    fun `should add spaes on both sides of equals`() {
+    fun `should add spaces on both sides of equals`() {
         fixAndCompare("EqualsExpected.kt", "EqualsTest.kt")
     }
+
+    @Test
+    @Tag(WarningNames.WRONG_WHITESPACE)
+    fun `should add spaces on both sides of braces in lambda`() {
+        fixAndCompare("BracesLambdaSpacesExpected.kt", "BracesLambdaSpacesTest.kt")
+    }
 }

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/spaces/WhiteSpaceRuleWarnTest.kt

@@ -10,6 +10,7 @@ import generated.WarningNames
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
 
+@Suppress("LargeClass")
 class WhiteSpaceRuleWarnTest : LintTestBase(::WhiteSpaceRule) {
     private val ruleId = "$DIKTAT_RULE_SET_ID:horizontal-whitespace"
     private val eolSpaceWarn = "${WRONG_WHITESPACE.warnText()} there should be no spaces in the end of line"
@@ -146,11 +147,11 @@ class WhiteSpaceRuleWarnTest : LintTestBase(::WhiteSpaceRule) {
         lintMethod(
             """
                     |fun foo(a: (Int) -> Int, b: Int) {
-                    |    foo({x: Int -> x}, 5)
+                    |    foo({ x: Int -> x }, 5)
                     |}
                     |
                     |fun bar(a: (Int) -> Int, b: Int) {
-                    |    bar( {x: Int -> x}, 5)
+                    |    bar( { x: Int -> x }, 5)
                     |}
                     |
                     |val lambda = { x: Int -> 2 * x }
@@ -615,4 +616,58 @@ class WhiteSpaceRuleWarnTest : LintTestBase(::WhiteSpaceRule) {
             LintError(10, 18, ruleId, tokenWarn("++", 1, null, 0, null), true)
         )
     }
+
+    @Test
+    @Tag(WarningNames.WRONG_WHITESPACE)
+    fun `check whitespaces around braces in lambda example - good`() {
+        lintMethod(
+            """
+                |fun foo() {
+                |    list.map { it.text }
+                |}
+            """.trimMargin()
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.WRONG_WHITESPACE)
+    fun `check whitespaces around braces in lambda example - bad`() {
+        lintMethod(
+            """
+                |fun foo() {
+                |    list.map {it.text}
+                |}
+            """.trimMargin(),
+            LintError(2, 14, ruleId, "${WRONG_WHITESPACE.warnText()} there should be a whitespace after {", true),
+            LintError(2, 22, ruleId, "${WRONG_WHITESPACE.warnText()} there should be a whitespace before }", true)
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.WRONG_WHITESPACE)
+    fun `should not trigger on braces with empty body #1`() {
+        lintMethod(
+            """
+                |val project = KotlinCoreEnvironment.createForProduction(
+                |   Disposable {},
+                |   compilerConfiguration,
+                |   EnvironmentConfigFiles.JVM_CONFIG_FILES
+                |).project
+            """.trimMargin()
+        )
+    }
+
+    @Test
+    @Tag(WarningNames.WRONG_WHITESPACE)
+    fun `should not trigger on braces with empty body #2`() {
+        lintMethod(
+            """
+                |val project = KotlinCoreEnvironment.createForProduction(
+                |   Disposable { },
+                |   compilerConfiguration,
+                |   EnvironmentConfigFiles.JVM_CONFIG_FILES
+                |).project
+            """.trimMargin()
+        )
+    }
 }

diktat-rules/src/test/resources/test/paragraph3/spaces/BracesLambdaSpacesExpected.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.spaces
+
+class Some {
+    fun foo() {
+        list.map { it.text }
+    }
+}
+

diktat-rules/src/test/resources/test/paragraph3/spaces/BracesLambdaSpacesTest.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.spaces
+
+class Some {
+    fun foo() {
+        list.map {it.text}
+    }
+}
+

diktat-rules/src/test/resources/test/paragraph3/spaces/LambdaAsArgumentExpected.kt

@@ -1,5 +1,5 @@
 package test.paragraph3.spaces
 
 fun foo(a: (Int) -> Int, b: Int) {
-    foo({x: Int -> x}, 5)
+    foo({ x: Int -> x }, 5)
 }

diktat-rules/src/test/resources/test/paragraph3/spaces/LambdaAsArgumentTest.kt

@@ -1,5 +1,5 @@
 package test.paragraph3.spaces
 
 fun foo(a: (Int) -> Int, b: Int) {
-    foo( {x: Int -> x}, 5)
+    foo( { x: Int -> x }, 5)
 }