Detekt Unsued Returns

build.gradle.kts

@@ -34,7 +34,9 @@ dependencies {
     testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
     testImplementation("io.gitlab.arturbosch.detekt:detekt-test:1.22.0")
     testImplementation("org.mockito:mockito-core:4.8.1")
-    testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
+    testImplementation("org.assertj:assertj-core:3.21.0")
 }
 
 tasks.test {

src/main/kotlin/io/agodadev/kraftdetekt/IgnoredReturnValueRule.kt

@@ -0,0 +1,47 @@
+package io.agodadev.kraftdetekt
+
+import io.gitlab.arturbosch.detekt.api.*
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isNothing
+import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.isUnit
+
+class IgnoredReturnValueRule(config: Config) : Rule(config) {
+    override val issue = Issue(
+        javaClass.simpleName,
+        Severity.Warning,
+        "This rule reports when a function call's return value is ignored.",
+        Debt.FIVE_MINS
+    )
+
+    override fun visitCallExpression(expression: KtCallExpression) {
+        super.visitCallExpression(expression)
+
+        val parent = expression.parent
+        if (parent is KtExpression && !parent.isUsedAsExpression(bindingContext)) {
+            val resolvedCall = expression.getResolvedCall(bindingContext) ?: return
+            val returnType = resolvedCall.resultingDescriptor.returnType ?: return
+
+            if (!returnType.isUnit() && !returnType.isNothing()) {
+                report(CodeSmell(
+                    issue,
+                    Entity.from(expression),
+                    "The return value of this function call is ignored."
+                ))
+            }
+        }
+    }
+}
+
+class IgnoredReturnValueRuleProvider : RuleSetProvider {
+    override val ruleSetId: String = "custom-rules"
+
+    override fun instance(config: Config): RuleSet {
+        return RuleSet(
+            ruleSetId,
+            listOf(IgnoredReturnValueRule(config))
+        )
+    }
+}

src/test/kotlin/io/agodadev/kraftdetekt/CustomDetektRuleTest.kt

@@ -1,16 +1,69 @@
 package io.agodadev.kraftdetekt
-
+import io.gitlab.arturbosch.detekt.api.Config
+import io.gitlab.arturbosch.detekt.test.compileAndLint
 import io.gitlab.arturbosch.detekt.test.TestConfig
-import org.junit.jupiter.api.Assertions
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
-class CustomDetektRuleTest {
+class IgnoredReturnValueRuleTest {
+
+    @Test
+    fun `reports ignored return values`() {
+        val code = """
+            fun returnsString(): String = "Hello"
+            fun returnsInt(): Int = 42
+            fun returnsNothing(): Nothing = throw Exception("Nothing")
+            fun returnsUnit(): Unit {}
+            
+            fun test() {
+                returnsString()
+                returnsInt()
+                returnsNothing()
+                returnsUnit()
+                val x = returnsString()
+                if (returnsInt() > 0) {}
+            }
+        """.trimIndent()
+
+        val findings = IgnoredReturnValueRule(Config.empty).compileAndLint(code)
+
+        assertThat(findings).hasSize(2)
+        assertThat(findings[0].message).isEqualTo("The return value of this function call is ignored.")
+        assertThat(findings[1].message).isEqualTo("The return value of this function call is ignored.")
+    }
 
     @Test
-    fun test1() {
-        val config = TestConfig()
-        val rule = CustomDetektRule(config)
-        Assertions.assertTrue(rule.issue.severity == io.gitlab.arturbosch.detekt.api.Severity.Warning)
+    fun `does not report when return value is used`() {
+        val code = """
+            fun returnsString(): String = "Hello"
+            fun returnsInt(): Int = 42
+            
+            fun test() {
+                val s = returnsString()
+                println(returnsInt())
+                if (returnsString().isNotEmpty()) {}
+            }
+        """.trimIndent()
+
+        val findings = IgnoredReturnValueRule(Config.empty).compileAndLint(code)
+
+        assertThat(findings).isEmpty()
     }
 
-}
+    @Test
+    fun `does not report Unit and Nothing return types`() {
+        val code = """
+            fun returnsNothing(): Nothing = throw Exception("Nothing")
+            fun returnsUnit(): Unit {}
+            
+            fun test() {
+                returnsNothing()
+                returnsUnit()
+            }
+        """.trimIndent()
+
+        val findings = IgnoredReturnValueRule(Config.empty).compileAndLint(code)
+
+        assertThat(findings).isEmpty()
+    }
+}