OptionalWhenBraces: fix false positive with lambda which has no arrow

detekt-rules/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/style/OptionalWhenBraces.kt

@@ -9,6 +9,7 @@ import io.gitlab.arturbosch.detekt.api.Rule
 import io.gitlab.arturbosch.detekt.api.Severity
 import io.gitlab.arturbosch.detekt.rules.hasCommentInside
 import org.jetbrains.kotlin.psi.KtBlockExpression
+import org.jetbrains.kotlin.psi.KtLambdaExpression
 import org.jetbrains.kotlin.psi.KtWhenExpression
 
 /**
@@ -40,15 +41,16 @@ class OptionalWhenBraces(config: Config = Config.empty) : Rule(config) {
     override fun visitWhenExpression(expression: KtWhenExpression) {
         for (entry in expression.entries) {
             val blockExpression = entry.expression as? KtBlockExpression
-            if (hasOneStatement(blockExpression) && hasOptionalBrace(blockExpression)) {
+            if (blockExpression?.hasUnnecessaryBraces() == true) {
                 report(CodeSmell(issue, Entity.from(entry), issue.description))
             }
         }
     }
 
-    private fun hasOneStatement(blockExpression: KtBlockExpression?) =
-            blockExpression?.statements?.size == 1 && !blockExpression.hasCommentInside()
-
-    private fun hasOptionalBrace(blockExpression: KtBlockExpression?) =
-            blockExpression != null && blockExpression.lBrace != null && blockExpression.rBrace != null
+    private fun KtBlockExpression.hasUnnecessaryBraces(): Boolean {
+        val singleStatement = statements.singleOrNull()?.takeIf {
+            !(it is KtLambdaExpression && it.functionLiteral.arrow == null)
+        }
+        return singleStatement != null && !hasCommentInside() && lBrace != null && rBrace != null
+    }
 }

detekt-rules/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/style/OptionalWhenBracesSpec.kt

@@ -38,5 +38,31 @@ class OptionalWhenBracesSpec : Spek({
                 }"""
             assertThat(subject.compileAndLint(code)).hasSize(1)
         }
+
+        context("the statement is a lambda expression") {
+            it("does not report if the lambda has no arrow") {
+                val code = """
+                    fun test(b: Boolean): (Int) -> Int {
+                        return when (b) {
+                            true -> { { it + 100 } }
+                            false -> { { it + 200  } }
+                        }
+                    }
+                """
+                assertThat(subject.compileAndLint(code)).isEmpty()
+            }
+
+            it("reports if the lambda has an arrow") {
+                val code = """
+                    fun test(b: Boolean): (Int) -> Int {
+                        return when (b) {
+                            true -> { { i -> i + 100 } }
+                            false -> { { i -> i + 200  } }
+                        }
+                    }
+                """
+                assertThat(subject.compileAndLint(code)).hasSize(2)
+            }
+        }
     }
 })