SONARKT-400 Migrate AbstractRegexCheck to kotlin-analysis-api

Author: leveretka

sonar-kotlin-api/src/main/java/org/sonarsource/kotlin/api/regex/AbstractRegexCheck.kt

@@ -16,6 +16,10 @@
  */
 package org.sonarsource.kotlin.api.regex
 
+import org.jetbrains.kotlin.analysis.api.resolution.KaExplicitReceiverValue
+import org.jetbrains.kotlin.analysis.api.resolution.KaFunctionCall
+import org.jetbrains.kotlin.analysis.api.symbols.name
+import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.KtBinaryExpression
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtExpression
@@ -24,9 +28,6 @@ import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.KtStringTemplateEntryWithExpression
 import org.jetbrains.kotlin.psi.KtStringTemplateExpression
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.util.getReceiverExpression
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.sonar.api.batch.fs.TextRange
 import org.sonarsource.analyzer.commons.regex.RegexIssueLocation
 import org.sonarsource.analyzer.commons.regex.RegexParseResult
@@ -41,25 +42,29 @@ import org.sonarsource.kotlin.api.checks.STRING_TYPE
 import org.sonarsource.kotlin.api.checks.predictRuntimeValueExpression
 import org.sonarsource.kotlin.api.frontend.KotlinFileContext
 import org.sonarsource.kotlin.api.frontend.TextRangeTracker
-import org.sonarsource.kotlin.api.checks.isPlus as isConcat
-import org.sonarsource.kotlin.api.reporting.SecondaryLocation
 import org.sonarsource.kotlin.api.reporting.KotlinTextRanges.textRange
+import org.sonarsource.kotlin.api.reporting.SecondaryLocation
+import org.sonarsource.kotlin.api.visiting.withKaSession
 import java.util.regex.Pattern
+import org.sonarsource.kotlin.api.checks.isPlus as isConcat
 
 val PATTERN_COMPILE_MATCHER = FunMatcher(qualifier = "java.util.regex.Pattern", name = "compile")
 val REGEX_MATCHER = ConstructorMatcher(typeName = "kotlin.text.Regex")
 val TO_REGEX_MATCHER = FunMatcher(qualifier = "kotlin.text", name = "toRegex", isExtensionFunction = true)
 
-private fun argGetter(argIndex: Int) = { resolvedCall: ResolvedCall<*> ->
-    resolvedCall.valueArgumentsByIndex?.getOrNull(argIndex)?.arguments?.getOrNull(0)?.getArgumentExpression()
+private fun argGetter(argIndex: Int) = { resolvedCall: KaFunctionCall<*> ->
+    resolvedCall.argumentMapping.keys.elementAtOrNull(argIndex)
 }
 
-private val referenceTargetGetter = { resolvedCall: ResolvedCall<*> ->
-    resolvedCall.getReceiverExpression()
+private val referenceTargetGetter = { resolvedCall: KaFunctionCall<*> ->
+    when (val receiver = resolvedCall.partiallyAppliedSymbol.extensionReceiver) {
+        is KaExplicitReceiverValue -> receiver.expression
+        else -> null
+    }
 }
 
 // TODO: add org.apache.commons.lang3.RegExUtils
-private val REGEX_FUNCTIONS: Map<FunMatcherImpl, Pair<(ResolvedCall<*>) -> KtExpression?, (ResolvedCall<*>) -> KtExpression?>> = mapOf(
+private val REGEX_FUNCTIONS: Map<FunMatcherImpl, Pair<(KaFunctionCall<*>) -> KtExpression?, (KaFunctionCall<*>) -> KtExpression?>> = mapOf(
     REGEX_MATCHER to (argGetter(0) to argGetter(1)),
     TO_REGEX_MATCHER to (referenceTargetGetter to argGetter(0)),
     PATTERN_COMPILE_MATCHER to (argGetter(0) to argGetter(1)),
@@ -102,13 +107,14 @@ abstract class AbstractRegexCheck : CallAbstractCheck() {
 
     override fun visitFunctionCall(
         callExpression: KtCallExpression,
-        resolvedCall: ResolvedCall<*>,
+        resolvedCall: KaFunctionCall<*>,
         matchedFun: FunMatcherImpl,
         kotlinFileContext: KotlinFileContext
     ) {
+
         REGEX_FUNCTIONS[matchedFun]!!.let { (regexStringArgExtractor, flagsArgExtractor) ->
             val regexCtx = regexStringArgExtractor(resolvedCall)
-                .collectResolvedListOfStringTemplates(kotlinFileContext.bindingContext)
+                .collectResolvedListOfStringTemplates()
                 // For now, we simply don't use any sequence that contains nulls (i.e. non-resolvable parts)
                 .takeIf { null !in it }?.filterNotNull()
                 ?.flatMap { it.entries.asSequence() }
@@ -118,7 +124,7 @@ abstract class AbstractRegexCheck : CallAbstractCheck() {
                     RegexContext(sourceTemplates.asIterable(), kotlinFileContext)
                 } ?: return
 
-            flagsArgExtractor(resolvedCall).extractRegexFlags(kotlinFileContext.bindingContext)
+            flagsArgExtractor(resolvedCall).extractRegexFlags()
                 .takeIf { flags -> Pattern.LITERAL !in flags }
                 ?.let { flags ->
 
@@ -168,24 +174,24 @@ private data class AnalyzerIssueReportInfo(
     val gap: Double?,
 )
 
-private fun KtExpression?.extractRegexFlags(bindingContext: BindingContext): FlagSet =
+private fun KtExpression?.extractRegexFlags(): FlagSet =
     FlagSet(
         this?.collectDescendantsOfType<KtReferenceExpression>()
-            ?.map { it.predictRuntimeValueExpression(bindingContext) }
+            ?.map { it.predictRuntimeValueExpression() }
             ?.flatMap { it.collectDescendantsOfType<KtNameReferenceExpression>() }
-            ?.mapNotNull { bindingContext[BindingContext.REFERENCE_TARGET, it] }
-            ?.mapNotNull { FLAGS[it.name.asString()] }
+            ?.mapNotNull { withKaSession { it.mainReference.resolveToSymbol()?.name?.asString() } }
+            ?.mapNotNull { FLAGS[it] }
             ?.fold(0, Int::or)
             ?: 0
     )
 
-private fun KtExpression?.collectResolvedListOfStringTemplates(bindingContext: BindingContext): Sequence<KtStringTemplateExpression?> =
-    this?.predictRuntimeValueExpression(bindingContext).let { predictedValue ->
+private fun KtExpression?.collectResolvedListOfStringTemplates(): Sequence<KtStringTemplateExpression?> =
+    this?.predictRuntimeValueExpression().let { predictedValue ->
         when {
             predictedValue is KtStringTemplateExpression -> sequenceOf(predictedValue)
             predictedValue is KtBinaryExpression && predictedValue.isConcat() ->
-                predictedValue.left.collectResolvedListOfStringTemplates(bindingContext) +
-                    predictedValue.right.collectResolvedListOfStringTemplates(bindingContext)
+                predictedValue.left.collectResolvedListOfStringTemplates() +
+                    predictedValue.right.collectResolvedListOfStringTemplates()
             else -> sequenceOf(null)
         }
     }