Implement rule UnnecessaryPartOfBinaryExpression

detekt-core/src/main/resources/default-detekt-config.yml

@@ -390,6 +390,8 @@ performance:
   SpreadOperator:
     active: true
     excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+  UnnecessaryPartOfBinaryExpression:
+    active: false
   UnnecessaryTemporaryInstantiation:
     active: true
 

detekt-rules-performance/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/performance/PerformanceProvider.kt

@@ -20,7 +20,8 @@ class PerformanceProvider : DefaultRuleSetProvider {
             SpreadOperator(config),
             UnnecessaryTemporaryInstantiation(config),
             ArrayPrimitive(config),
-            CouldBeSequence(config)
+            CouldBeSequence(config),
+            UnnecessaryPartOfBinaryExpression(config),
         )
     )
 }

detekt-rules-performance/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/performance/UnnecessaryPartOfBinaryExpression.kt

@@ -0,0 +1,47 @@
+package io.gitlab.arturbosch.detekt.rules.performance
+
+import io.gitlab.arturbosch.detekt.api.CodeSmell
+import io.gitlab.arturbosch.detekt.api.Config
+import io.gitlab.arturbosch.detekt.api.Debt
+import io.gitlab.arturbosch.detekt.api.Entity
+import io.gitlab.arturbosch.detekt.api.Issue
+import io.gitlab.arturbosch.detekt.api.Rule
+import io.gitlab.arturbosch.detekt.api.Severity
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+
+/**
+ * Unnecessary binary expression add complexity to the code and accomplish nothing. They should be removed.
+ * The rule works with all binary expression included if and when condition. The rule also works with all predicates.
+ *
+ * <noncompliant>
+ * val foo = true
+ *
+ * if (foo || foo) {
+ * }
+ * </noncompliant>
+ *
+ * <compliant>
+ * val foo = true
+ * if (foo) {
+ * }
+ * </compliant>
+ *
+ */
+class UnnecessaryPartOfBinaryExpression(config: Config = Config.empty) : Rule(config) {
+
+    override val issue: Issue = Issue(
+        "UnnecessaryPartOfBinaryExpression",
+        Severity.Performance,
+        "Detects duplicate condition into binary expression and recommends to remove unnecessary checks",
+        Debt.FIVE_MINS
+    )
+
+    override fun visitBinaryExpression(expression: KtBinaryExpression) {
+        super.visitBinaryExpression(expression)
+        val children = expression.children.map { it.text.replace(Regex("\\s"), "") }
+
+        if (children.size != children.distinct().size) {
+            report(CodeSmell(issue, Entity.from(expression), issue.description))
+        }
+    }
+}

detekt-rules-performance/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/performance/UnnecessaryPartOfBinaryExpressionSpec.kt

@@ -0,0 +1,147 @@
+package io.gitlab.arturbosch.detekt.rules.performance
+
+import io.gitlab.arturbosch.detekt.test.compileAndLint
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class UnnecessaryPartOfBinaryExpressionSpec {
+
+    @Test
+    fun `verify foo or foo detected`() {
+        val code = """
+            fun bar() {
+                val foo = true
+                if (foo || foo) {
+                    //TODO    
+                }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify object-foo or object-foo detected`() {
+        val code = """
+            class Bar(val bar: Boolean)
+            fun bar() {
+                val bar = Bar(true)
+
+                if (bar.bar || bar.bar) {
+                    //TODO    
+                }
+            }
+
+
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify foo more 5 and foo more 5 detected`() {
+        val code = """
+            fun bar() {
+                val foo = 1
+                if (foo > 1 && foo > 1) {
+                    //TODO    
+                }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify foo more 5 && foo more 5 detected un trim`() {
+        val code = """
+            fun bar() {
+                val foo = 1
+                if (foo> 1 && foo >1) {
+                    //TODO    
+                }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify object-foo && object-foo detected`() {
+        val code = """
+            class Bar(val bar: Boolean)
+
+            fun bar() {
+                val bar = Bar(true)
+
+                if (bar.bar && bar.bar) {
+                    //TODO    
+                }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify foo does not report`() {
+        val code = """
+            fun bar() {
+                val foo = true
+                if (foo) {
+                    //TODO    
+                }
+            }
+
+
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(0)
+    }
+
+    @Test
+    fun `verify more and less if works as expected`() {
+        val code = """
+            fun bar() {
+                val foo = 0
+                val bar = 1
+                if (foo > bar || foo > 1) {
+                    //TODO    
+                }
+            }
+
+
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(0)
+    }
+
+    @Test
+    fun `verify into filter function`() {
+        val code = """
+            fun bar() {
+                val list = listOf<Int>()
+
+                list.filter { it > 1 || it > 1 }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+
+    @Test
+    fun `verify into when`() {
+        val code = """
+            fun bar() {
+                val foo = true
+                when {
+                    foo || foo -> {
+
+                    }
+                }
+            }
+        """
+        val findings = UnnecessaryPartOfBinaryExpression().compileAndLint(code)
+        assertThat(findings).hasSize(1)
+    }
+}