Fix false positive on it usages when type parameter is specified (#…

…6850)

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

@@ -6,9 +6,7 @@ import io.gitlab.arturbosch.detekt.api.Config
 import io.gitlab.arturbosch.detekt.api.Entity
 import io.gitlab.arturbosch.detekt.api.Rule
 import io.gitlab.arturbosch.detekt.rules.IT_LITERAL
-import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.psi.KtLambdaExpression
-import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 
 /**
  * Lambda expressions are one of the core features of the language. They often include very small chunks of
@@ -28,6 +26,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
  *
  * <compliant>
  * a?.let { it.plus(1) } // Much better to use implicit it
+ * a?.let { value: Int -> value.plus(1) } // Better as states the type more clearly
  * foo.flatMapObservable(Observable::fromIterable) // Here we can have a method reference
  *
  * // For multiline blocks it is usually better come up with a clear and more meaningful name
@@ -49,14 +48,17 @@ class ExplicitItLambdaParameter(config: Config) : Rule(
 
     override fun visitLambdaExpression(lambdaExpression: KtLambdaExpression) {
         super.visitLambdaExpression(lambdaExpression)
-        if (lambdaExpression.getStrictParentOfType<KtCallableReferenceExpression>() != null) return
         val parameterNames = lambdaExpression.valueParameters.map { it.name }
         if (IT_LITERAL in parameterNames) {
-            val message = if (parameterNames.size == 1) {
-                "This explicit usage of `it` as the lambda parameter name can be omitted."
-            } else {
-                "`it` should not be used as name for a lambda parameter."
-            }
+            val message =
+                if (
+                    parameterNames.size == 1 &&
+                    lambdaExpression.valueParameters[0].typeReference == null
+                ) {
+                    "This explicit usage of `it` as the lambda parameter name can be omitted."
+                } else {
+                    "`it` should not be used as name for a lambda parameter."
+                }
             report(
                 CodeSmell(
                     Entity.from(lambdaExpression),

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

@@ -1,8 +1,8 @@
 package io.gitlab.arturbosch.detekt.rules.style
 
 import io.gitlab.arturbosch.detekt.api.Config
+import io.gitlab.arturbosch.detekt.test.assertThat
 import io.gitlab.arturbosch.detekt.test.compileAndLint
-import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 
@@ -21,6 +21,9 @@ class ExplicitItLambdaParameterSpec {
                 """.trimIndent()
             )
             assertThat(findings).hasSize(1)
+            assertThat(findings[0]).hasMessage(
+                "This explicit usage of `it` as the lambda parameter name can be omitted."
+            )
         }
 
         @Test
@@ -35,20 +38,32 @@ class ExplicitItLambdaParameterSpec {
             assertThat(findings).hasSize(1)
         }
 
+        @Test
+        fun `does not reports when parameter type is declared explicitly when variable name is not it`() {
+            val findings = subject.compileAndLint(
+                """
+                    fun f() {
+                        val lambda = { value: Int -> value.toString() }
+                    }
+                """.trimIndent()
+            )
+            assertThat(findings).isEmpty()
+        }
+
         @Test
         fun `does not report when parameter type is declared explicitly for un-inferrable lambda`() {
             val findings = subject.compileAndLint(
                 """
                     fun f1(): (Int) -> Int {
-                        return { it: Int -> it.inc() }::invoke
+                        return { value: Int -> value.inc() }::invoke
                     }
 
                     fun f2(): (Int) -> Int {
                         return { value: Int -> value.inc() }::invoke
                     }
 
                     fun f3(): (((Int) -> Int) -> Unit) -> (Int) -> Int {
-                        return { it: Int -> it.inc() }::also
+                        return { value: Int -> value.inc() }::also
                     }
                 """.trimIndent()
             )
@@ -60,7 +75,7 @@ class ExplicitItLambdaParameterSpec {
             val findings = subject.compileAndLint(
                 """
                     fun f(): (Int) -> Int {
-                        return ({ it: Int -> it.inc() })::invoke
+                        return ({ value: Int -> value.inc() })::invoke
                     }
                 """.trimIndent()
             )
@@ -112,15 +127,28 @@ class ExplicitItLambdaParameterSpec {
         }
 
         @Test
-        fun `does not report when parameter type is declared explicitly for multi params un-inferrable lambda`() {
+        fun `does not report when parameter type with is declared explicitly for multi params un-inferrable lambda`() {
             val findings = subject.compileAndLint(
                 """
                     fun f(): (Int, Int) -> Int {
-                        return { it: Int, a: Int -> (it + a).inc() }::invoke
+                        return { value: Int, a: Int -> (value + a).inc() }::invoke
                     }
                 """.trimIndent()
             )
             assertThat(findings).isEmpty()
         }
+
+        @Test
+        fun `does report when parameter type with name it when declared explicitly for multi params un-inferrable lambda`() {
+            val findings = subject.compileAndLint(
+                """
+                    fun f(): (Int, Int) -> Int {
+                        return { it: Int, a: Int -> (it + a).inc() }::invoke
+                    }
+                """.trimIndent()
+            )
+            assertThat(findings).hasSize(1)
+            assertThat(findings[0]).hasMessage("`it` should not be used as name for a lambda parameter.")
+        }
     }
 }