RUM-16478: Improving performance

Author: satween

tools/detekt/src/main/kotlin/com/datadog/tools/detekt/rules/sdk/UnsafeThirdPartyFunctionCall.kt

@@ -41,13 +41,20 @@ class UnsafeThirdPartyFunctionCall(
 
     private val codeParser = CodeParser()
     private val ruleParser = DetektConfigParser()
-    private val configValidator = DetektConfigValidator(ruleParser)
+    private val configValidator = DetektConfigValidator()
     private val internalPackagePrefix: String by config(defaultValue = "")
     private val treatUnknownFunctionAsThrowing: Boolean by config(defaultValue = true)
     private val knownSafeCalls: List<SignatureRule> by config(emptyList(), ruleParser::parseSafeCalls)
     private val knownThrowingCalls: List<SignatureRule> by config(emptyList(), ruleParser::parseThrowingCalls)
     private val caughtExceptions = Stack<Set<String>>()
 
+    // Exact entries are looked up via O(1) map; wildcards fall through to list scan.
+    // Throwing category is always checked before safe category (preserves original semantics).
+    private val exactThrowingCalls: Map<String, SignatureRule>
+    private val wildcardThrowingCalls: List<SignatureRule>
+    private val exactSafeCalls: Map<String, SignatureRule>
+    private val wildcardSafeCalls: List<SignatureRule>
+
     override val issue: Issue = Issue(
         javaClass.simpleName,
         Severity.Defect,
@@ -58,6 +65,10 @@ class UnsafeThirdPartyFunctionCall(
 
     init {
         configValidator.validate(knownSafeCalls, knownThrowingCalls)
+        exactThrowingCalls = knownThrowingCalls.filterNot { it.hasWildcards }.associateBy { it.source }
+        wildcardThrowingCalls = knownThrowingCalls.filter { it.hasWildcards }
+        exactSafeCalls = knownSafeCalls.filterNot { it.hasWildcards }.associateBy { it.source }
+        wildcardSafeCalls = knownSafeCalls.filter { it.hasWildcards }
     }
 
     override fun visitTryExpression(expression: KtTryExpression) {
@@ -77,26 +88,25 @@ class UnsafeThirdPartyFunctionCall(
             return
         }
 
-        classifyAndReport(
-            expression,
-            signature = resolvedCall.call,
-            params = codeParser.parseFormalParams(expression, bindingContext)
-        )
+        val params = codeParser.parseFormalParams(expression, bindingContext)
+        classifyAndReport(expression, signature = resolvedCall.call, params = params)
     }
 
     private fun classifyAndReport(expression: KtCallExpression, signature: String, params: List<KtMethodParameter>) {
-        knownThrowingCalls.firstOrNull { it.matches(signature) }
-            ?.let { throwingMatch ->
-                throwingMatch.validate(params)
-                checkCallThrowingExceptions(expression, signature, throwingMatch.exceptions)
-                return
-            }
-
-        knownSafeCalls.firstOrNull { it.matches(signature) }
-            ?.let { safeMatch ->
-                safeMatch.validate(params)
-                return
-            }
+        val throwingMatch = exactThrowingCalls[signature]
+            ?: wildcardThrowingCalls.firstOrNull { it.matches(signature) }
+        if (throwingMatch != null) {
+            throwingMatch.validate(params)
+            checkCallThrowingExceptions(expression, signature, throwingMatch.exceptions)
+            return
+        }
+
+        val safeMatch = exactSafeCalls[signature]
+            ?: wildcardSafeCalls.firstOrNull { it.matches(signature) }
+        if (safeMatch != null) {
+            safeMatch.validate(params)
+            return
+        }
 
         if (treatUnknownFunctionAsThrowing) {
             reportUnsafeCall(

tools/detekt/src/main/kotlin/com/datadog/tools/detekt/rules/sdk/rule/thirdparty/DetektConfigValidator.kt

@@ -9,9 +9,7 @@ package com.datadog.tools.detekt.rules.sdk.rule.thirdparty
 /**
  * Validates parsed UnsafeThirdPartyFunctionCall config entries.
  */
-internal class DetektConfigValidator(
-    private val ruleParser: DetektConfigParser = DetektConfigParser()
-) {
+internal class DetektConfigValidator {
 
     fun validate(
         knownSafeCalls: List<SignatureRule>,
@@ -36,8 +34,9 @@ internal class DetektConfigValidator(
         safePatterns: List<SignatureRule>,
         throwingPatterns: List<SignatureRule>
     ) = buildList {
+        val throwingByKey = throwingPatterns.groupBy { it.overlapKey }
         safePatterns.forEach { safe ->
-            throwingPatterns.forEach { throwing ->
+            throwingByKey[safe.overlapKey].orEmpty().forEach { throwing ->
                 if (safe.intersects(throwing)) {
                     add(
                         "  - '${safe.source}' (knownSafeCalls) overlaps with " +
@@ -49,9 +48,9 @@ internal class DetektConfigValidator(
     }
 
     private fun validateThrowingCallIsNotInSafeCallsConfig(safePatterns: List<SignatureRule>) = buildList {
-        val semanticUnsafePatterns = ruleParser.parseThrowingCalls(semanticUnsafeCalls)
+        val semanticUnsafeByKey = semanticUnsafePatterns.groupBy { it.overlapKey }
         safePatterns.forEach { safe ->
-            semanticUnsafePatterns.forEach { unsafe ->
+            semanticUnsafeByKey[safe.overlapKey].orEmpty().forEach { unsafe ->
                 if (safe.intersects(unsafe)) {
                     add(
                         "  - '${safe.source}' (knownSafeCalls) overlaps with known unsafe " +
@@ -66,10 +65,15 @@ internal class DetektConfigValidator(
         configName: String,
         patterns: List<SignatureRule>
     ) = buildList {
-        for (i in patterns.indices) {
-            for (j in i + 1 until patterns.size) {
-                if (patterns[i].intersects(patterns[j])) {
-                    add("  - '${patterns[i].source}' duplicates '${patterns[j].source}' in $configName")
+        patterns.groupBy { it.overlapKey }.values.forEach { matchingPatterns ->
+            for (i in matchingPatterns.indices) {
+                for (j in i + 1 until matchingPatterns.size) {
+                    if (matchingPatterns[i].intersects(matchingPatterns[j])) {
+                        add(
+                            "  - '${matchingPatterns[i].source}' duplicates " +
+                                "'${matchingPatterns[j].source}' in $configName"
+                        )
+                    }
                 }
             }
         }
@@ -80,5 +84,7 @@ internal class DetektConfigValidator(
             "java.lang.Thread.interrupt():java.lang.SecurityException",
             "kotlin.Array.first(kotlin.Function1):java.util.NoSuchElementException"
         )
+
+        private val semanticUnsafePatterns = DetektConfigParser().parseThrowingCalls(semanticUnsafeCalls)
     }
 }

tools/detekt/src/main/kotlin/com/datadog/tools/detekt/rules/sdk/rule/thirdparty/SignatureRule.kt

@@ -24,6 +24,10 @@ internal class SignatureRule(
 ) {
 
     private val methodPart: String = source.substringBefore('(')
+    internal val overlapKey: OverlapKey = OverlapKey(methodPart, paramSlots.size)
+
+    /** True when this rule has no wildcard slots and can be matched with a plain map lookup. */
+    internal val hasWildcards: Boolean = wildcardSlots.isNotEmpty()
 
     /** Returns true if this rule's pattern matches the given fully-qualified [signature] string. */
     fun matches(signature: String): Boolean =
@@ -59,6 +63,8 @@ internal class SignatureRule(
 
     internal data class WildcardSlot(val index: Int, val symbol: String)
 
+    internal data class OverlapKey(val methodPart: String, val paramCount: Int)
+
     private companion object {
 
         private fun slotsMatches(a: String, b: String): Boolean {

tools/detekt/src/test/kotlin/com/datadog/tools/detekt/rules/sdk/UnsafeThirdPartyFunctionCallTest.kt

@@ -79,6 +79,19 @@ internal class UnsafeThirdPartyFunctionCallTest {
         assertThat(findings).hasSize(1)
     }
 
+    @Test
+    fun `M throw exception W init {invalid detekt config}`() {
+        // Given
+        val config = TestConfig(
+            "knownSafeCalls" to listOf("kotlin.Array.first(kotlin.Function1)")
+        )
+
+        // When / Then
+        assertThrows<IllegalStateException> {
+            UnsafeThirdPartyFunctionCall(config)
+        }
+    }
+
     @Test
     fun `ignore call on internal package extension function`() {
         // Given
@@ -777,5 +790,4 @@ internal class UnsafeThirdPartyFunctionCallTest {
     }
 
     // endregion
-
 }

tools/detekt/src/test/kotlin/com/datadog/tools/detekt/rules/sdk/rule/thirdparty/DetektConfigValidatorTest.kt

@@ -12,7 +12,7 @@ import org.junit.jupiter.api.assertThrows
 internal class DetektConfigValidatorTest {
 
     private val parser = DetektConfigParser()
-    private val testedValidator = DetektConfigValidator(parser)
+    private val testedValidator = DetektConfigValidator()
 
     @Test
     fun `M throw exception W validate() {known unsafe literal is listed as safe}`() {