try without RequiresTypeResolution for compatibility (#6)

Co-authored-by: Yatheesha Lokesha <yatheesha.lokesha@agoda.com>

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

@@ -1,17 +1,14 @@
 package io.agodadev.kraftdetekt
 
 import io.gitlab.arturbosch.detekt.api.*
-import io.gitlab.arturbosch.detekt.api.internal.RequiresTypeResolution
 import org.jetbrains.kotlin.com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
 import org.jetbrains.kotlin.types.typeUtil.isNothing
 import org.jetbrains.kotlin.types.typeUtil.isUnit
 
 const val IGNORED_RETURN_VALUE: String = "AG001: The return value of this function call is ignored. see https://github.com/agoda-com/agoda-kraft/blob/main/doc/AG001.md"
 
-@RequiresTypeResolution
 class IgnoredReturnValueRule(config: Config) : Rule(config) {
     override val issue = Issue(
         javaClass.simpleName,
@@ -20,7 +17,6 @@ class IgnoredReturnValueRule(config: Config) : Rule(config) {
         Debt.FIVE_MINS
     )
 
-
     override fun visitCallExpression(expression: KtCallExpression) {
         super.visitCallExpression(expression)
 
@@ -29,38 +25,29 @@ class IgnoredReturnValueRule(config: Config) : Rule(config) {
         }
 
         val resolvedCall = expression.getResolvedCall(bindingContext) ?: return
-
         val returnType = resolvedCall.resultingDescriptor.returnType ?: return
 
         if (!returnType.isUnit() && !returnType.isNothing()) {
             val parent = expression.parent
+            val ignoredExpressions = setOf(
+                KtValueArgument::class,
+                KtProperty::class,
+                KtReturnExpression::class,
+                KtDotQualifiedExpression::class,
+                KtWhenConditionWithExpression::class
+            )
             when {
-                parent is KtValueArgument -> return
-                parent is KtProperty -> return
-                parent is KtReturnExpression -> return
-                parent is KtBinaryExpression && parent.operationToken.toString() == "EQ" -> return
+                parent::class in ignoredExpressions -> return
+                parent is KtBinaryExpression && parent.operationToken.toString() in setOf("EQ", "GT", "LT", "GTEQ", "LTEQ", "EQEQ", "EXCLEQ") -> return
                 parent is KtIfExpression && expression == parent.condition -> return
-                parent is KtWhenConditionWithExpression -> return
-                parent is KtBinaryExpression && parent.operationToken.toString() in setOf("GT", "LT", "GTEQ", "LTEQ", "EQEQ", "EXCLEQ") -> return
-                parent is KtDotQualifiedExpression -> return
                 parent is KtBlockExpression -> {
                     val isLastStatement = parent.statements.lastOrNull() == expression
                     val isOnlyStatement = parent.statements.size == 1
                     if (!isLastStatement && !isOnlyStatement) {
-                        report(CodeSmell(
-                            issue,
-                            Entity.from(expression),
-                            IGNORED_RETURN_VALUE
-                        ))
+                        reportIgnoredReturnValue(expression)
                     }
                 }
-                else -> {
-                    report(CodeSmell(
-                        issue,
-                        Entity.from(expression),
-                        IGNORED_RETURN_VALUE
-                    ))
-                }
+                else -> reportIgnoredReturnValue(expression)
             }
         }
     }
@@ -75,4 +62,12 @@ class IgnoredReturnValueRule(config: Config) : Rule(config) {
         }
         return false
     }
+
+    private fun reportIgnoredReturnValue(expression: KtExpression) {
+        report(CodeSmell(
+            issue,
+            Entity.from(expression),
+            IGNORED_RETURN_VALUE
+        ))
+    }
 }