ElseCaseInsteadOfExhaustiveWhen - Add ignoredSubjectTypes config key (#5623)

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

@@ -425,6 +425,7 @@ potential-bugs:
       - 'java.util.HashMap'
   ElseCaseInsteadOfExhaustiveWhen:
     active: false
+    ignoredSubjectTypes: []
   EqualsAlwaysReturnsTrueOrFalse:
     active: true
   EqualsWithHashCodeExist:

detekt-rules-errorprone/src/main/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/ElseCaseInsteadOfExhaustiveWhen.kt

@@ -7,7 +7,10 @@ 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 io.gitlab.arturbosch.detekt.api.config
+import io.gitlab.arturbosch.detekt.api.internal.Configuration
 import io.gitlab.arturbosch.detekt.api.internal.RequiresTypeResolution
+import io.gitlab.arturbosch.detekt.rules.fqNameOrNull
 import org.jetbrains.kotlin.cfg.WhenChecker
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.calls.util.getType
@@ -59,6 +62,12 @@ class ElseCaseInsteadOfExhaustiveWhen(config: Config = Config.empty) : Rule(conf
         Debt.FIVE_MINS
     )
 
+    @Configuration(
+        "List of fully qualified types which should be ignored for when expressions with a subject. " +
+            "Example `kotlinx.serialization.json.JsonObject`"
+    )
+    private val ignoredSubjectTypes: List<String> by config(emptyList())
+
     override fun visitWhenExpression(whenExpression: KtWhenExpression) {
         super.visitWhenExpression(whenExpression)
 
@@ -70,6 +79,10 @@ class ElseCaseInsteadOfExhaustiveWhen(config: Config = Config.empty) : Rule(conf
         if (whenExpression.elseExpression == null) return
 
         val subjectType = subjectExpression.getType(bindingContext)
+        if (ignoredSubjectTypes.contains(subjectType?.fqNameOrNull()?.toString())) {
+            return
+        }
+
         val isEnumSubject = WhenChecker.getClassDescriptorOfTypeIfEnum(subjectType) != null
         val isSealedSubject = isNonExpectedSealedClass(subjectType)
         val isBooleanSubject = subjectType?.isBooleanOrNullableBoolean() == true

detekt-rules-errorprone/src/test/kotlin/io/gitlab/arturbosch/detekt/rules/bugs/ElseCaseInsteadOfExhaustiveWhenSpec.kt

@@ -1,6 +1,7 @@
 package io.gitlab.arturbosch.detekt.rules.bugs
 
 import io.gitlab.arturbosch.detekt.rules.KotlinCoreEnvironmentTest
+import io.gitlab.arturbosch.detekt.test.TestConfig
 import io.gitlab.arturbosch.detekt.test.compileAndLintWithContext
 import io.gitlab.arturbosch.detekt.test.lintWithContext
 import org.assertj.core.api.Assertions.assertThat
@@ -152,6 +153,114 @@ class ElseCaseInsteadOfExhaustiveWhenSpec(private val env: KotlinCoreEnvironment
         }
     }
 
+    @Nested
+    inner class `Various ignoreSubjectTypes configurations` {
+
+        @Test
+        fun `does not report if _when_ contains _else_ case for ignored _enum_ subject type`() {
+            val code = """
+            package com.example
+
+            enum class Color {
+                RED,
+                GREEN,
+                BLUE
+            }
+
+            fun whenOnEnumPasses(c: Color) {
+                when (c) {
+                    Color.BLUE -> {}
+                    Color.GREEN -> {}
+                    else -> {}
+                }
+            }
+            """.trimIndent()
+            assertThat(
+                ElseCaseInsteadOfExhaustiveWhen(
+                    TestConfig(mapOf("ignoredSubjectTypes" to listOf("com.example.Color")))
+                ).compileAndLintWithContext(env, code)
+            ).isEmpty()
+        }
+
+        @Test
+        fun `does not report if _when_ contains _else_ case for ignored _sealed_ subject type`() {
+            val code = """
+                package com.example
+
+                sealed class Variant {
+                    object VariantA : Variant()
+                    class VariantB : Variant()
+                    object VariantC : Variant()
+                }
+
+                fun whenOnSealedPasses(v: Variant) {
+                    when (v) {
+                        is Variant.VariantA -> {}
+                        is Variant.VariantB -> {}
+                        else -> {}
+                    }
+                }
+            """.trimIndent()
+            assertThat(
+                ElseCaseInsteadOfExhaustiveWhen(
+                    TestConfig(mapOf("ignoredSubjectTypes" to listOf("com.example.Variant")))
+                ).compileAndLintWithContext(env, code)
+            ).isEmpty()
+        }
+
+        @Test
+        fun `reports if _when_ contains _else_ case for non-ignored _enum_ subject type`() {
+            val code = """
+            package com.example
+
+            enum class Color {
+                RED,
+                GREEN,
+                BLUE
+            }
+
+            fun whenOnEnumFails(c: Color) {
+                when (c) {
+                    Color.BLUE -> {}
+                    Color.GREEN -> {}
+                    else -> {}
+                }
+            }
+            """.trimIndent()
+            assertThat(
+                ElseCaseInsteadOfExhaustiveWhen(
+                    TestConfig(mapOf("ignoredSubjectTypes" to listOf("com.example.Class")))
+                ).compileAndLintWithContext(env, code)
+            ).hasSize(1)
+        }
+
+        @Test
+        fun `reports if _when_ contains _else_ case for non-ignored _sealed_ subject type`() {
+            val code = """
+                package com.example
+
+                sealed class Variant {
+                    object VariantA : Variant()
+                    class VariantB : Variant()
+                    object VariantC : Variant()
+                }
+
+                fun whenOnSealedPasses(v: Variant) {
+                    when (v) {
+                        is Variant.VariantA -> {}
+                        is Variant.VariantB -> {}
+                        else -> {}
+                    }
+                }
+            """.trimIndent()
+            assertThat(
+                ElseCaseInsteadOfExhaustiveWhen(
+                    TestConfig(mapOf("ignoredSubjectTypes" to listOf("com.example.Class")))
+                ).compileAndLintWithContext(env, code)
+            ).hasSize(1)
+        }
+    }
+
     @Nested
     inner class `Expected sealed class` {
         @Test