From 3abac1d56a9ca6cae3a1e48d71dc380da5a0ccc0 Mon Sep 17 00:00:00 2001
From: Dmitriy Novozhilov <dmitriy.novozhilov@jetbrains.com>
Date: Tue, 8 Feb 2022 13:38:26 +0300
Subject: [PATCH] [Test] Allow to enable some diagnostics in tests if it's
 severity is disabled

---
 .../test/services/DiagnosticsService.kt       | 42 +++++++++++--------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt
index 597b468374f..f63fac8cd8d 100644
--- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt
+++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt
@@ -19,21 +19,33 @@ class DiagnosticsService(val testServices: TestServices) : TestService {
         )
     }
 
-    private val conditionsPerModule: MutableMap<TestModule, Pair<Condition<String>, Condition<Severity>>> = mutableMapOf()
+    private val conditionsPerModule: MutableMap<TestModule, DiagnosticConditions> = mutableMapOf()
+
+    private data class DiagnosticConditions(
+        val allowedDiagnostics: Set<String>,
+        val disabledDiagnostics: Set<String>,
+        val severityMap: Map<Severity, Boolean>
+    )
 
     fun shouldRenderDiagnostic(module: TestModule, name: String, severity: Severity): Boolean {
-        val (nameCondition, severityCondition) = conditionsPerModule.getOrPut(module) {
+        val conditions = conditionsPerModule.getOrPut(module) {
             computeDiagnosticConditionForModule(module)
         }
-        return severityCondition(severity) && nameCondition(name)
+
+        val severityAllowed = conditions.severityMap.getOrDefault(severity, true)
+
+        return if (severityAllowed) {
+            name !in conditions.disabledDiagnostics || name in conditions.allowedDiagnostics
+        } else {
+            name in conditions.allowedDiagnostics
+        }
     }
 
-    private fun computeDiagnosticConditionForModule(module: TestModule): Pair<Condition<String>, Condition<Severity>> {
+    private fun computeDiagnosticConditionForModule(module: TestModule): DiagnosticConditions {
         val diagnosticsInDirective = module.directives[DiagnosticsDirectives.DIAGNOSTICS]
         val enabledNames = mutableSetOf<String>()
         val disabledNames = mutableSetOf<String>()
-        val enabledSeverities = mutableSetOf<Severity>()
-        val disabledSeverities = mutableSetOf<Severity>()
+        val severityMap = mutableMapOf<Severity, Boolean>()
         for (diagnosticInDirective in diagnosticsInDirective) {
             val enabled = when {
                 diagnosticInDirective.startsWith("+") -> true
@@ -43,23 +55,17 @@ class DiagnosticsService(val testServices: TestServices) : TestService {
             val name = diagnosticInDirective.substring(1)
             val severity = severityNameMapping[name]
             if (severity != null) {
-                val collection = if (enabled) enabledSeverities else disabledSeverities
-                collection += severity
+                severityMap[severity] = enabled
             } else {
                 val collection = if (enabled) enabledNames else disabledNames
                 collection += name
             }
         }
-        return computeCondition(enabledNames, disabledNames) to computeCondition(enabledSeverities, disabledSeverities)
-    }
-
-    private fun <T : Any> computeCondition(enabled: Set<T>, disabled: Set<T>): Condition<T> {
-        if (disabled.isEmpty()) return Conditions.alwaysTrue()
-        var condition = !Conditions.oneOf(disabled)
-        if (enabled.isNotEmpty()) {
-            condition = condition or Conditions.oneOf(enabled)
-        }
-        return condition.cached()
+        return DiagnosticConditions(
+            enabledNames,
+            disabledNames,
+            severityMap
+        )
     }
 }