bugfix/empty-lambdas(#796)

### What's done: * Fixed bug
saveourtool · Mar 19, 2021 · 727aff3 · 727aff3
1 parent d9b6b6e
commit 727aff3
Show file tree

Hide file tree

Showing 2 changed files with 45 additions and 5 deletions.
diff --git a/diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter3/EmptyBlock.kt b/diktat-rules/src/main/kotlin/org/cqfn/diktat/ruleset/rules/chapter3/EmptyBlock.kt
@@ -9,13 +9,19 @@ import org.cqfn.diktat.ruleset.utils.*
 
 import com.pinterest.ktlint.core.ast.ElementType
 import com.pinterest.ktlint.core.ast.ElementType.CALL_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.DOT_QUALIFIED_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.FILE
 import com.pinterest.ktlint.core.ast.ElementType.FUNCTION_LITERAL
 import com.pinterest.ktlint.core.ast.ElementType.IDENTIFIER
+import com.pinterest.ktlint.core.ast.ElementType.LAMBDA_EXPRESSION
+import com.pinterest.ktlint.core.ast.ElementType.LPAR
 import com.pinterest.ktlint.core.ast.ElementType.RBRACE
+import com.pinterest.ktlint.core.ast.ElementType.VALUE_PARAMETER
 import com.pinterest.ktlint.core.ast.ElementType.WHITE_SPACE
 import org.jetbrains.kotlin.com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl
+import org.jetbrains.kotlin.psi.psiUtil.parents
 
 /**
  * Rule that checks if empty code blocks (`{  }`) are used and checks their formatting.
@@ -28,6 +34,9 @@ class EmptyBlock(configRules: List<RulesConfig>) : DiktatRule(
         val configuration = EmptyBlockStyleConfiguration(
             configRules.getRuleConfig(EMPTY_BLOCK_STRUCTURE_ERROR)?.configuration ?: emptyMap()
         )
+        if (node.elementType == FILE) {
+            println(node.prettyPrint())
+        }
         searchNode(node, configuration)
     }
 
@@ -41,7 +50,7 @@ class EmptyBlock(configRules: List<RulesConfig>) : DiktatRule(
 
     @Suppress("UnsafeCallOnNullableType", "TOO_LONG_FUNCTION")
     private fun checkEmptyBlock(node: ASTNode, configuration: EmptyBlockStyleConfiguration) {
-        if (node.treeParent.isOverridden() || isAnonymousSamClass(node)) {
+        if (node.treeParent.isOverridden() || isAnonymousSamClass(node) || isLambdaUsedAsFunction(node)) {
             return
         }
         if (node.isBlockEmpty()) {
@@ -82,18 +91,32 @@ class EmptyBlock(configRules: List<RulesConfig>) : DiktatRule(
         }
     }
 
-    @Suppress("UnsafeCallOnNullableType", "WRONG_WHITESPACE")
-    private fun isAnonymousSamClass(node: ASTNode) : Boolean =
+    @Suppress("UnsafeCallOnNullableType")
+    private fun isAnonymousSamClass(node: ASTNode): Boolean =
             if (node.elementType == FUNCTION_LITERAL && node.hasParent(CALL_EXPRESSION)) {
-                // We are checking identifier because it is not class in AST
-                // , SAM conversions are indistinguishable from lambdas.
+                // We are checking identifier because it is not class in AST,
+                // SAM conversions are indistinguishable from lambdas.
                 // So we just verify that identifier is in PascalCase
                 val valueArgument = node.findParentNodeWithSpecificType(CALL_EXPRESSION)!!
                 valueArgument.findLeafWithSpecificType(IDENTIFIER)?.text?.isPascalCase() ?: false
             } else {
                 false
             }
 
+    private fun isLambdaUsedAsFunction(node: ASTNode): Boolean {
+        val parents = node.parents()
+        if (parents.any { it.elementType == CALL_EXPRESSION }) {
+            val callExpression = parents.find { it.elementType == CALL_EXPRESSION }!!
+            // excepting cases like list.map { }
+            return callExpression.treeParent.elementType != DOT_QUALIFIED_EXPRESSION
+        } else if (parents.any { it.elementType == LAMBDA_EXPRESSION }) {
+            val lambdaExpression = parents.find { it.elementType == LAMBDA_EXPRESSION }!!
+            // cases like A({}). Here Lambda expression is used as a value parameter.
+            return lambdaExpression.treeParent.elementType == VALUE_PARAMETER
+        }
+        return false
+    }
+
     /**
      * [RuleConfiguration] for empty blocks formatting
      */

diff --git a/diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/EmptyBlockWarnTest.kt b/diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/EmptyBlockWarnTest.kt
@@ -204,4 +204,21 @@ class EmptyBlockWarnTest : LintTestBase(::EmptyBlock) {
             rulesConfigList = rulesConfigListEmptyBlockExist
         )
     }
+
+    @Test
+    @Tag(WarningNames.EMPTY_BLOCK_STRUCTURE_ERROR)
+    fun `should not trigger on empty lambdas as a functions`() {
+        lintMethod(
+                """
+                |fun foo(bar: () -> Unit = {})
+                |
+                |class Some {
+                |   fun bar() {
+                |       A({})
+                |   }
+                |}
+            """.trimMargin(),
+                rulesConfigList = rulesConfigListEmptyBlockExist
+        )
+    }
 }