[Test] Add debug names to unnamed test disposables

- This helps to track down disposables which are never disposed, and
  reduces confusion when printing disposables in general (the names will
  now be meaningful, instead of endless lists of "newDisposable" and
  "TestDisposable").

^KT-64099

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/AbstractInBlockModificationTest.kt

@@ -139,7 +139,7 @@ private fun doTestInBlockModification(
  * @return **true** if out-of-block happens
  */
 private fun LLFirDeclarationModificationService.modifyElement(element: PsiElement): Boolean {
-    val disposable = Disposer.newDisposable()
+    val disposable = Disposer.newDisposable("${LLFirDeclarationModificationService::class.simpleName}.disposable")
     var isOutOfBlock = false
     try {
         project.analysisMessageBus.connect(disposable).subscribe(

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

@@ -214,7 +214,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
         }
 
         fun writeFilesOnDisk() {
-            val disposable = Disposer.newDisposable()
+            val disposable = Disposer.newDisposable("Disposable for ${FilesWriter::class.qualifiedName}.writeFilesOnDisk")
             val environment = KotlinCoreEnvironment.createForTests(
                 disposable,
                 configuration.copy().apply {

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -46,7 +46,7 @@ class BuiltInsSerializer(
             dependOnOldBuiltIns: Boolean,
             onComplete: (totalSize: Int, totalFiles: Int) -> Unit
         ) {
-            val rootDisposable = Disposer.newDisposable()
+            val rootDisposable = Disposer.newDisposable("Disposable for ${BuiltInsSerializer::class.simpleName}.analyzeAndSerialize")
             val messageCollector = createMessageCollector()
             val performanceManager = object : CommonCompilerPerformanceManager(presentableName = "test") {}
             try {

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.kt

@@ -97,7 +97,7 @@ abstract class CLICompiler<A : CommonCompilerArguments> : CLITool<A>() {
             val canceledStatus = services[CompilationCanceledStatus::class.java]
             ProgressIndicatorAndCompilationCanceledStatus.setCompilationCanceledStatus(canceledStatus)
 
-            val rootDisposable = Disposer.newDisposable()
+            val rootDisposable = Disposer.newDisposable("Disposable for ${CLICompiler::class.simpleName}.execImpl")
             try {
                 setIdeaIoUseFallback()
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -891,7 +891,7 @@ class CompileServiceImpl(
         if (compilationOptions.targetPlatform != CompileService.TargetPlatform.JVM)
             CompileService.CallResult.Error("Sorry, only JVM target platform is supported now")
         else {
-            val disposable = Disposer.newDisposable()
+            val disposable = Disposer.newDisposable("Disposable for ${CompileServiceImpl::class.simpleName}.leaseReplSession")
             val messageCollector = CompileServicesFacadeMessageCollector(servicesFacade, compilationOptions)
             val repl = KotlinJvmReplService(
                 disposable, port, compilerId, templateClasspath, templateClassName,

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt

@@ -153,7 +153,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractFrontendModularizedTest() {
     }
 
     override fun processModule(moduleData: ModuleData): ProcessorAction {
-        val disposable = Disposer.newDisposable()
+        val disposable = Disposer.newDisposable("Disposable for ${FirResolveModularizedTotalKotlinTest::class.simpleName}.processModule")
         val configuration = createDefaultConfiguration(moduleData)
         configureLanguageVersionSettings(configuration, moduleData, LanguageVersion.fromVersionString(LANGUAGE_VERSION_K2)!!)
         val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/NonFirResolveModularizedTotalKotlinTest.kt

@@ -122,7 +122,7 @@ class NonFirResolveModularizedTotalKotlinTest : AbstractFrontendModularizedTest(
     }
 
     override fun processModule(moduleData: ModuleData): ProcessorAction {
-        val disposable = Disposer.newDisposable()
+        val disposable = Disposer.newDisposable("Disposable for ${NonFirResolveModularizedTotalKotlinTest::class.simpleName}.processModule")
         val environment = configureAndSetupEnvironment(moduleData, disposable)
 
         runAnalysis(environment)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -100,7 +100,7 @@ open class IncrementalFirJvmCompilerRunner(
 
         val exitCode = ExitCode.OK
         val allCompiledSources = LinkedHashSet<File>()
-        val rootDisposable = Disposer.newDisposable()
+        val rootDisposable = Disposer.newDisposable("Disposable for ${IncrementalFirJvmCompilerRunner::class.simpleName}.runCompiler")
 
         try {
             // - configuration

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -107,7 +107,8 @@ open class IncrementalJvmCompilerRunner(
             psiFileFactory.createFileFromText(file.nameWithoutExtension, JavaLanguage.INSTANCE, file.readText())
 
         private val psiFileFactory: PsiFileFactory by lazy {
-            val rootDisposable = Disposer.newDisposable()
+            val rootDisposable =
+                Disposer.newDisposable("Disposable for PSI file factory of ${IncrementalJvmCompilerRunner::class.simpleName}")
             val configuration = compilerConfiguration
             val environment =
                 KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/parsing/parseFileUtils.kt

@@ -30,7 +30,7 @@ fun classesFqNames(files: Set<File>): Set<String> {
     val existingKotlinFiles = files.filter { it.name.endsWith(".kt", ignoreCase = true) && it.isFile }
     if (existingKotlinFiles.isEmpty()) return emptySet()
 
-    val disposable = Disposer.newDisposable()
+    val disposable = Disposer.newDisposable("Disposable for org.jetbrains.kotlin.incremental.parsing.classesFqNames")
 
     return try {
         classesFqNames(existingKotlinFiles, disposable)

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

@@ -16,7 +16,7 @@ import java.lang.reflect.Field
 
 class ApplicationEnvironmentDisposer : TestExecutionListener {
     companion object {
-        val ROOT_DISPOSABLE: Disposable = Disposer.newDisposable()
+        val ROOT_DISPOSABLE: Disposable = Disposer.newDisposable("${ApplicationEnvironmentDisposer::class.simpleName}.ROOT_DISPOSABLE")
     }
 
     override fun testPlanExecutionFinished(testPlan: TestPlan) {

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

@@ -50,7 +50,7 @@ class TestConfigurationImpl(
 
     val originalBuilder: TestConfigurationBuilder.ReadOnlyBuilder
 ) : TestConfiguration(), TestService {
-    override val rootDisposable: Disposable = TestDisposable()
+    override val rootDisposable: Disposable = TestDisposable("${TestConfigurationImpl::class.simpleName}.rootDisposable")
     override val testServices: TestServices = TestServices()
 
     init {

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.test.utils
 
 import com.intellij.openapi.Disposable
 
-class TestDisposable : Disposable {
+class TestDisposable(val debugName: String) : Disposable {
     @Volatile
     var isDisposed = false
         private set
@@ -15,4 +15,6 @@ class TestDisposable : Disposable {
     override fun dispose() {
         isDisposed = true
     }
+
+    override fun toString(): String = debugName
 }

compiler/tests-common/tests/org/jetbrains/kotlin/test/KlibTestUtil.kt

@@ -46,7 +46,7 @@ object KlibTestUtil {
         configuration.put(CommonConfigurationKeys.MODULE_NAME, libraryName)
         configuration.addKotlinSourceRoots(sourceFiles.map { it.absolutePath })
 
-        val rootDisposable = Disposer.newDisposable()
+        val rootDisposable = Disposer.newDisposable("Disposable for ${KlibTestUtil::class.simpleName}.compileCommonSourcesToKlib")
         val module = try {
             val environment = KotlinCoreEnvironment.createForTests(
                 parentDisposable = rootDisposable,

compiler/tests/org/jetbrains/kotlin/cli/jvm/repl/GenericReplTest.kt

@@ -199,7 +199,7 @@ internal class TestRepl(
 ) : Closeable {
     val application = ApplicationManager.getApplication()
 
-    private val disposable: Disposable by lazy { Disposer.newDisposable() }
+    private val disposable: Disposable by lazy { Disposer.newDisposable("${TestRepl::class.simpleName}.disposable") }
 
     val emptyScriptArgs = ScriptArgsWithTypes(arrayOf(emptyArray<String>()), arrayOf(Array<String>::class))
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/FastJarFSTest.kt

@@ -23,7 +23,7 @@ class FastJarFSTest : TestCase() {
 
     private var fs: FastJarFileSystem? = null
     private var coreAppEnv: JavaCoreApplicationEnvironment? = null
-    private val rootDisposable = Disposer.newDisposable()
+    private val rootDisposable = Disposer.newDisposable("${FastJarFSTest::class.simpleName}.rootDisposable")
 
     override fun setUp() {
         super.setUp()

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -72,7 +72,7 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
     }
 
     private fun serialize(configuration: CompilerConfiguration, metaFile: File) {
-        val rootDisposable = Disposer.newDisposable()
+        val rootDisposable = Disposer.newDisposable("Disposable for ${KotlinJavascriptSerializerTest::class.simpleName}.serialize")
         try {
             val environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
             val files = environment.getSourceFiles()

js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt

@@ -82,7 +82,11 @@ abstract class AbstractInvalidationTest(
 
     private val zipAccessor = ZipFileSystemCacheableAccessor(2)
     protected val environment =
-        KotlinCoreEnvironment.createForParallelTests(TestDisposable(), CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
+        KotlinCoreEnvironment.createForParallelTests(
+            TestDisposable("${AbstractInvalidationTest::class.simpleName}.rootDisposable"),
+            CompilerConfiguration(),
+            EnvironmentConfigFiles.JS_CONFIG_FILES,
+        )
 
     @AfterEach
     protected fun clearZipAccessor() {

libraries/tools/ide-plugin-dependencies-validator/src/org/jetbrains/kotlin/ide/plugin/dependencies/validator/ExperimentalOptInUsageInSourceChecker.kt

@@ -83,7 +83,7 @@ object ExperimentalOptInUsageInSourceChecker {
 
     private fun createProjectForParsing(): Project {
         return KotlinCoreEnvironment.createForProduction(
-            Disposer.newDisposable(),
+            Disposer.newDisposable("Disposable for project of ${ExperimentalOptInUsageInSourceChecker::class.simpleName}"),
             CompilerConfiguration(),
             EnvironmentConfigFiles.JVM_CONFIG_FILES
         ).project

libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/ExecuteKotlinScriptMojo.java

@@ -163,7 +163,7 @@ public class ExecuteKotlinScriptMojo extends AbstractMojo {
     private void executeScriptFile(File scriptFile) throws MojoExecutionException {
         initCompiler();
 
-        Disposable rootDisposable = Disposer.newDisposable();
+        Disposable rootDisposable = Disposer.newDisposable("Disposable for ExecuteKotlinScriptMojo.executeScriptFile");
 
         try {
             MavenPluginLogMessageCollector messageCollector = new MavenPluginLogMessageCollector(getLog());

native/objcexport-header-generator/src/test/kotlin/org/jetbrains/kotlin/backend/konan/testUtils/AbstractObjCExportHeaderGeneratorTest.kt

@@ -20,7 +20,7 @@ abstract class AbstractObjCExportHeaderGeneratorTest(
         fun generateHeaders(disposable: Disposable, root: File): String
     }
 
-    private val testRootDisposable = Disposer.newDisposable()
+    private val testRootDisposable = Disposer.newDisposable("${AbstractObjCExportHeaderGeneratorTest::class.simpleName}.testRootDisposable")
     protected val objCExportTestDataDir = testDataDir.resolve("objcexport")
 
     @After

native/objcexport-header-generator/src/test/kotlin/org/jetbrains/kotlin/backend/konan/tests/ObjCExportMapperTest.kt

@@ -31,7 +31,7 @@ import kotlin.test.assertNull
  * The test also acts as quick entry point for debugging the [ObjCExportMapper]
  */
 class ObjCExportMapperTest : InlineSourceTestEnvironment {
-    override val testDisposable = Disposer.newDisposable()
+    override val testDisposable = Disposer.newDisposable("${ObjCExportMapperTest::class.simpleName}.testDisposable")
     override val kotlinCoreEnvironment: KotlinCoreEnvironment = createKotlinCoreEnvironment(testDisposable)
 
     @TempDir

native/objcexport-header-generator/src/test/kotlin/org/jetbrains/kotlin/backend/konan/tests/ObjCExportNamerTest.kt

@@ -35,7 +35,7 @@ import kotlin.test.assertEquals
  */
 class ObjCExportNamerTest : InlineSourceTestEnvironment {
 
-    override val testDisposable = Disposer.newDisposable()
+    override val testDisposable = Disposer.newDisposable("${ObjCExportNamerTest::class.simpleName}.testDisposable")
 
     override val kotlinCoreEnvironment = createKotlinCoreEnvironment(testDisposable)
 

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/jvmCompilationUtil.kt

@@ -36,7 +36,7 @@ internal fun makeCompiledModule(generationState: GenerationState) =
 inline fun <T> withMessageCollectorAndDisposable(
     script: SourceCode? = null,
     parentMessageCollector: MessageCollector? = null,
-    disposable: Disposable = Disposer.newDisposable(),
+    disposable: Disposable = Disposer.newDisposable("Default disposable for scripting compiler"),
     disposeOnSuccess: Boolean = true,
     body: (ScriptDiagnosticsMessageCollector, Disposable) -> ResultWithDiagnostics<T>
 ): ResultWithDiagnostics<T> {

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/repl/GenericReplCompiler.kt

@@ -36,7 +36,12 @@ open class GenericReplCompiler(
         scriptDefinition: KotlinScriptDefinition,
         compilerConfiguration: CompilerConfiguration,
         messageCollector: MessageCollector
-    ) : this(Disposer.newDisposable(), scriptDefinition, compilerConfiguration, messageCollector)
+    ) : this(
+        Disposer.newDisposable("Default disposable for ${GenericReplCompiler::class.simpleName}"),
+        scriptDefinition,
+        compilerConfiguration,
+        messageCollector
+    )
 
     private val checker =
         GenericReplChecker(

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/services/FirScriptDefinitionProviderService.kt

@@ -59,7 +59,15 @@ class FirScriptDefinitionProviderService(
             val makeConfigurationProvider = configurationProvider?.let { { it } }
                 ?: {
                     // TODO: check if memory can leak in MockProject (probably not too important, since currently the providers are set externaly in important cases)
-                    CliScriptDependenciesProvider(MockProject(null, Disposer.newDisposable()))
+                    CliScriptDependenciesProvider(
+                        MockProject(
+                            null,
+                            Disposer.newDisposable(
+                                "Disposable for project of ${CliScriptDependenciesProvider::class.simpleName} created by" +
+                                        " ${FirScriptDefinitionProviderService::class.simpleName}"
+                            ),
+                        ),
+                    )
                 }
 
             return Factory { session -> FirScriptDefinitionProviderService(session, makeDefinitionsProvider, makeConfigurationProvider) }

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/plugin/testUtil.kt

@@ -271,7 +271,7 @@ internal fun <R> withTempDir(keyName: String = "tmp", body: (File) -> R): R {
 }
 
 internal fun <R> withDisposable(body: (Disposable) -> R) {
-    val disposable = Disposer.newDisposable()
+    val disposable = Disposer.newDisposable("Disposable for scripting compiler tests")
     try {
         body(disposable)
     } finally {
@@ -279,7 +279,7 @@ internal fun <R> withDisposable(body: (Disposable) -> R) {
     }
 }
 
-class TestDisposable : Disposable {
+class TestDisposable(val debugName: String) : Disposable {
     @Volatile
     var isDisposed = false
         private set
@@ -287,6 +287,8 @@ class TestDisposable : Disposable {
     override fun dispose() {
         isDisposed = true
     }
+
+    override fun toString(): String = debugName
 }
 
 fun CompilerConfiguration.updateWithBaseCompilerArguments() {

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/CollectScriptCompilationDependenciesTest.kt

@@ -28,7 +28,8 @@ private const val testDataPath = "plugins/scripting/scripting-compiler/testData/
 
 class CollectScriptCompilationDependenciesTest : TestCase() {
 
-    protected val testRootDisposable: Disposable = TestDisposable()
+    protected val testRootDisposable: Disposable =
+        TestDisposable("${CollectScriptCompilationDependenciesTest::class.simpleName}.testRootDisposable")
 
     fun testCascadeImport() {
         runTest("imp_imp_leaf.req1.kts", listOf("imp_leaf.req1.kts", "leaf.req1.kts"))

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/CompileTimeFibonacciTest.kt

@@ -34,7 +34,7 @@ import kotlin.script.experimental.util.filterByAnnotationType
 private const val testDataPath = "plugins/scripting/scripting-compiler/testData/compiler/compileTimeFibonacci"
 
 class CompileTimeFibonacciTest : TestCase() {
-    private val testRootDisposable: Disposable = TestDisposable()
+    private val testRootDisposable: Disposable = TestDisposable("${CompileTimeFibonacciTest::class.simpleName}.testRootDisposable")
 
     fun testFibonacciWithSupportedNumbersImplementsTheCorrectConstants() {
         val outputLines = runScript("supported.fib.kts")

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/ConstructAnnotationTest.kt

@@ -40,7 +40,7 @@ private annotation class TestAnnotation(vararg val options: String)
 private annotation class AnnotationWithVarArgAndArray(vararg val options: String, val moreOptions: Array<String>)
 
 class ConstructAnnotationTest : TestCase() {
-    private val testRootDisposable: Disposable = TestDisposable()
+    private val testRootDisposable: Disposable = TestDisposable("${ConstructAnnotationTest::class.simpleName}.testRootDisposable")
 
     fun testAnnotationEmptyVarArg() {
         val annotations = annotations("TestAnnotationEmptyVarArg.kts", TestAnnotation::class)

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/ScriptCliCompilationTest.kt

@@ -35,7 +35,7 @@ private const val testDataPath = "plugins/scripting/scripting-compiler/testData/
 
 class ScriptCliCompilationTest : TestCase() {
 
-    protected val testRootDisposable: Disposable = TestDisposable()
+    protected val testRootDisposable: Disposable = TestDisposable("${ScriptCliCompilationTest::class.simpleName}.testRootDisposable")
 
     fun testPrerequisites() {
         Assert.assertTrue(thisClasspath.isNotEmpty())

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/ScriptTemplateTest.kt

@@ -362,7 +362,7 @@ class ScriptTemplateTest : TestCase() {
         messageCollector: MessageCollector,
         includeKotlinRuntime: Boolean
     ): Class<*>? {
-        val rootDisposable = Disposer.newDisposable()
+        val rootDisposable = Disposer.newDisposable("Disposable for ${ScriptTemplateTest::class.simpleName}")
         try {
             val additionalClasspath = System.getProperty("kotlin.test.script.classpath")?.split(File.pathSeparator)
                 ?.mapNotNull { File(it).takeIf { file -> file.exists() } }.orEmpty().toTypedArray()

plugins/scripting/scripting-compiler/tests/org/jetbrains/kotlin/scripting/compiler/test/ScriptTest.kt

@@ -116,7 +116,7 @@ class ScriptTest : TestCase() {
             if (suppressOutput) MessageCollector.NONE
             else PrintingMessageCollector(System.err, MessageRenderer.PLAIN_FULL_PATHS, false)
 
-        val rootDisposable = Disposer.newDisposable()
+        val rootDisposable = Disposer.newDisposable("Disposable for ${ScriptTest::class.simpleName}")
         try {
             val configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK)
             configuration.updateWithBaseCompilerArguments()