[Test] Add ability to configure access to application disposable in test configuration

This is needed to unbound CompilerConfigurationProvider from ApplicationEnvironmentDisposer,
  which depends on classes from JUnit 5. This will allow to safely use
  compiler test framework with base test framework different from JUnit 5

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.ExecutionListenerBasedDisposableProvider
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
@@ -151,6 +152,7 @@ abstract class AbstractFrontendApiTest : TestWithDisposable() {
         useSourcePreprocessor(::ExpressionMarkersSourceFilePreprocessor)
         useAdditionalService { ExpressionMarkerProvider() }
         useAdditionalService(::TestKtModuleProvider)
+        useAdditionalService<ApplicationDisposableProvider> { ExecutionListenerBasedDisposableProvider() }
         configureTest(this)
 
         startingArtifactFactory = { ResultingArtifact.Source() }

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -415,6 +415,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
 
         assertions = JUnit5Assertions
         useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
+        useAdditionalService<ApplicationDisposableProvider> { ExecutionListenerBasedDisposableProvider() }
         useSourcePreprocessor(*AbstractKotlinCompilerTest.defaultPreprocessors.toTypedArray())
         useDirectives(*AbstractKotlinCompilerTest.defaultDirectiveContainers.toTypedArray())
         class AndroidTransformingPreprocessor(testServices: TestServices) : SourceFilePreprocessor(testServices) {

compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ApplicationDisposableProvider.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.test.services
+
+import com.intellij.openapi.Disposable
+
+abstract class ApplicationDisposableProvider : TestService {
+    abstract fun getApplicationRootDisposable(): Disposable
+}
+
+val TestServices.applicationDisposableProvider: ApplicationDisposableProvider by TestServices.testServiceAccessor()

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/ApplicationEnvironmentDisposer.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Disposer
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.test.services.ApplicationDisposableProvider
 import org.junit.platform.launcher.TestExecutionListener
 import org.junit.platform.launcher.TestPlan
 import java.lang.reflect.Field
@@ -26,3 +27,9 @@ class ApplicationEnvironmentDisposer : TestExecutionListener {
         ourApplicationField.set(null, null)
     }
 }
+
+class ExecutionListenerBasedDisposableProvider : ApplicationDisposableProvider() {
+    override fun getApplicationRootDisposable(): Disposable {
+        return ApplicationEnvironmentDisposer.ROOT_DISPOSABLE
+    }
+}

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt

@@ -46,7 +46,7 @@ class TestConfigurationBuilder {
     private val configurationsByNegativeTestDataCondition: MutableList<Pair<Regex, TestConfigurationBuilder.() -> Unit>> = mutableListOf()
     private val additionalServices: MutableList<ServiceRegistrationData> = mutableListOf()
 
-    private var compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)? = null
+    private var compilerConfigurationProvider: ((TestServices, Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)? = null
     private var runtimeClasspathProviders: MutableList<Constructor<RuntimeClasspathProvider>> = mutableListOf()
 
     lateinit var testInfo: KotlinTestInfo
@@ -184,7 +184,7 @@ class TestConfigurationBuilder {
     }
 
     @TestInfrastructureInternals
-    fun useCustomCompilerConfigurationProvider(provider: (Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider) {
+    fun useCustomCompilerConfigurationProvider(provider: (TestServices, Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider) {
         compilerConfigurationProvider = provider
     }
 
@@ -286,7 +286,7 @@ class TestConfigurationBuilder {
         val additionalServices: List<ServiceRegistrationData>
             get() = builder.additionalServices
 
-        val compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?
+        val compilerConfigurationProvider: ((TestServices, Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?
             get() = builder.compilerConfigurationProvider
         val runtimeClasspathProviders: List<Constructor<RuntimeClasspathProvider>>
             get() = builder.runtimeClasspathProviders

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt

@@ -38,7 +38,7 @@ class TestConfigurationImpl(
     metaTestConfigurators: List<Constructor<MetaTestConfigurator>>,
     afterAnalysisCheckers: List<Constructor<AfterAnalysisChecker>>,
 
-    compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?,
+    compilerConfigurationProvider: ((TestServices, Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?,
     runtimeClasspathProviders: List<Constructor<RuntimeClasspathProvider>>,
 
     override val metaInfoHandlerEnabled: Boolean,
@@ -103,8 +103,8 @@ class TestConfigurationImpl(
             register(SourceFileProvider::class, sourceFileProvider)
 
             val environmentProvider =
-                compilerConfigurationProvider?.invoke(rootDisposable, this@TestConfigurationImpl.environmentConfigurators)
+                compilerConfigurationProvider?.invoke(this, rootDisposable, this@TestConfigurationImpl.environmentConfigurators)
-                    ?: CompilerConfigurationProviderImpl(rootDisposable, this@TestConfigurationImpl.environmentConfigurators)
+                    ?: CompilerConfigurationProviderImpl(this, rootDisposable, this@TestConfigurationImpl.environmentConfigurators)
             register(CompilerConfigurationProvider::class, environmentProvider)
 
             register(AssertionsService::class, assertions)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractKotlinCompilerTest.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.test.runners
 
 import com.intellij.testFramework.TestDataFile
 import org.jetbrains.kotlin.test.Constructor
+import org.jetbrains.kotlin.test.ExecutionListenerBasedDisposableProvider
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.testRunner
 import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
@@ -39,7 +40,9 @@ abstract class AbstractKotlinCompilerTest {
         }
 
         val defaultConfiguration: TestConfigurationBuilder.() -> Unit = {
+            assertions = JUnit5Assertions
             useAdditionalService<TemporaryDirectoryManager>(::TemporaryDirectoryManagerImpl)
+            useAdditionalService<ApplicationDisposableProvider> { ExecutionListenerBasedDisposableProvider() }
             useSourcePreprocessor(*defaultPreprocessors.toTypedArray())
             useDirectives(*defaultDirectiveContainers.toTypedArray())
             configureDebugFlags()
@@ -48,7 +51,6 @@ abstract class AbstractKotlinCompilerTest {
     }
 
     protected val configuration: TestConfigurationBuilder.() -> Unit = {
-        assertions = JUnit5Assertions
         defaultConfiguration()
         configure(this)
     }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.platform.js.isJs
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.ApplicationEnvironmentDisposer
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.model.FrontendKinds
@@ -34,7 +33,7 @@ import org.jetbrains.kotlin.test.model.TestFile
 import org.jetbrains.kotlin.test.model.TestModule
 import java.io.File
 
-abstract class CompilerConfigurationProvider : TestService {
+abstract class CompilerConfigurationProvider(val testServices: TestServices) : TestService {
     abstract val testRootDisposable: Disposable
 
     protected abstract fun getKotlinCoreEnvironment(module: TestModule): KotlinCoreEnvironment
@@ -65,9 +64,10 @@ abstract class CompilerConfigurationProvider : TestService {
 val TestServices.compilerConfigurationProvider: CompilerConfigurationProvider by TestServices.testServiceAccessor()
 
 open class CompilerConfigurationProviderImpl(
+    testServices: TestServices,
     override val testRootDisposable: Disposable,
     val configurators: List<AbstractEnvironmentConfigurator>
-) : CompilerConfigurationProvider() {
+) : CompilerConfigurationProvider(testServices) {
     private val cache: MutableMap<TestModule, KotlinCoreEnvironment> = mutableMapOf()
 
     override fun getKotlinCoreEnvironment(module: TestModule): KotlinCoreEnvironment {
@@ -88,7 +88,7 @@ open class CompilerConfigurationProviderImpl(
             else -> error("Unknown platform: $platform")
         }
         val applicationEnvironment = KotlinCoreEnvironment.getOrCreateApplicationEnvironmentForTests(
-            ApplicationEnvironmentDisposer.ROOT_DISPOSABLE,
+            testServices.applicationDisposableProvider.getApplicationRootDisposable(),
             CompilerConfiguration()
         )
         val initialConfiguration = createCompilerConfiguration(module)